90% of engineers are using AI tools. Maybe half of them use it regularly. And almost none of them can clearly explain how they work with it — what separates casual AI use from true agentic engineering.
That gap — between using AI and being able to articulate the workflow — is where the real opportunity lives.
The Shift That Changes Everything
We’ve moved through three phases fast.
Early 2020s: AI finishes your lines. Fancy autocomplete.
2022: AI suggests entire functions. GitHub Copilot breaks through. Millions of developers start paying attention.
2025–2026: AI executes. It takes a task, breaks it down, touches the right files, runs the tests, and comes back with a pull request.
That’s not a faster horse. That’s a fundamentally different way of working.
Armin Ronacher — creator of Flask — put it well: “We’re no longer just using machines. We’re now working with them.”
The engineers capturing that value aren’t the ones prompting harder. They’re the ones who’ve changed how they think about the work.
The Right Mental Model for Agentic Engineering
Stop thinking about AI as a tool you pick up and put down. Start thinking about it as an energetic, enthusiastic, extremely well-read, often confidently wrong junior developer.
That junior dev is incredibly fast. No ego. No fatigue. Happy to rewrite something six times. Seen every language, every framework, every Stack Overflow answer ever written.
But here’s the critical part: they have no judgment. They don’t know your business context. They don’t understand why you made that architectural decision three months ago. They’ll write code that’s technically correct and contextually wrong — and do it confidently.
Armin saves 30% of his day because he knows what to hand off and what to keep for himself. He’s not blindly accepting suggestions. He’s directing the work.
That distinction is everything in agentic engineering.
Context Engineering Is the #1 Skill
The most important thing you can master as an agentic engineer isn’t prompting. It’s context management.
Here’s why it’s harder than it sounds:
Context is expensive. Every token in the window gets sent as input on every call. It adds up.
More context ≠ better results. Quality degrades past roughly 50% context fill. The model gets dumber — not in a metaphorical sense, but with measurably worse output.
Bad context poisons everything. Mixed tasks, outdated comments, walking back a wrong direction without starting fresh — these corrupt the agent’s output in ways that are hard to trace.
The habits that fix this:
- One task per session
- Persist important context outside the window (scratch pads, memory files, agents.md) and pull in only what’s relevant for this step
- Watch your context meter — when it’s feeling off-track, trust that instinct
- Start a new session. Have the agent summarise where you are, review it, then start fresh with just that context
For a deeper dive into the tools that make context management easier, see The Ultimate Claude Code Setup: Plugins, Workflow, and Tools.
The Research → Plan → Implement Loop
Most people jump straight to implementation. That’s the mistake.
A bad line of research can become hundreds of lines of bad code. The time you skip in planning, you pay back triple in debugging.
The loop that works:
1. Research — Use a non-coding mode first. Understand the system. Where are the relevant files? What patterns exist? What are the edge cases? Let AI help you brainstorm, but don’t let it write code yet.
2. Plan — Produce an explicit plan file. Step-by-step changes, test commands to verify, what’s in scope and what isn’t. Once the plan is tight, a smaller/faster/cheaper model can execute it.
3. Implement — Start a new session with just the plan. Low context, focused execution. Commit frequently. Use Git as your first PR review before it goes to your team.
The human’s highest-leverage time is at the research and planning phases. By the time you’re implementing, the hard thinking should be done.
As Dex Horthy says, “AI can’t replace thinking. It can only amplify the thinking you’ve done — or the lack of thinking you haven’t done.”
Once you’ve got this loop down, the next step is tooling. These 32 Claude Code hacks will help you squeeze more out of every agentic engineering session.
Configure Your Agents Properly
Three things to set up:
Modes — Research mode (read-only), Architect mode (planning), Code mode (implementation). Each one has a different job. Use them accordingly.
agents.md — The always-on readme for your repo. Conventions, build/test commands, non-negotiables. Every agent that touches your codebase should have this in context.
skills.md — Reusable playbooks for specific workflows. Not always-on — on demand. If you’re doing the same kind of task repeatedly, it belongs in a skill.
On MCP servers: powerful, but every enabled server adds tokens to every call. Disable what you’re not actively using. The Postgres MCP is dead weight when you’re doing front-end work.
For a complete walkthrough of configuration that supports agentic engineering workflows, read Claude Code Best Practices: The Complete Guide to 10x Developer Productivity.
Where to Start with Agentic Engineering
Pick one tool. Get reps. Lots of them.
It’s part art, part science — and that means you can’t shortcut the reps. You need to develop a feel for what the model can handle on its own and what needs your hand on the wheel.
Try the research → plan → implement loop on your next feature. See what happens.
Some senior engineers working this way are saying they’re having more fun programming than they have in years. The tedious work ships to the agent. The harder problems — architecture, judgment, context — stay with the human.
That’s the bet worth making.
Get one practical AI workflow every week. No fluff. Just the systems, tools, and techniques that actually ship.