What is Agentic Engineering?
The role that didn't exist two years ago — and why every company will need it.
March 2026 · 10 min read
Agentic engineering is the practice of building software by orchestrating AI coding agents as primary development infrastructure — not optional tooling. Agentic engineers use tools like Cursor, Claude Code, and GitHub Copilot as force multipliers — delegating implementation to agents while focusing on the problems that actually matter: defining problems clearly, verifying agent output, and making architectural decisions under uncertainty.
This is not an AI/ML role. Agentic engineers don't build models. They build software, faster, by designing the environments that agents execute against. The mental model shift is from craftsperson to architect. From typing to thinking.
The Bottleneck Flip
Traditional software development assumes code production is slow and review is fast. You spend most of your time writing code; reviewing it is relatively quick. Every process built around this assumption — sprints, story points, WIP limits, estimation ceremonies — reflects that bottleneck.
Agentic development inverts this. Code production is near-instant. An agent can generate a complete feature implementation in minutes. The bottleneck flips: the constraint is now human judgment, not human typing. Can you define the problem precisely enough? Can you evaluate whether the output is correct? Can you make the architectural call on what to build next?
This single flip cascades through everything. If the bottleneck is human judgment, then:
- Sprint batching becomes overhead. When agents produce code in minutes, batch-and-commit cycles slow you down.
- Story points stop making sense. You're no longer estimating implementation effort. You're estimating human attention cost.
- Ticket quality becomes the #1 throughput lever. Agents make bad specs fail faster, not better. The spec is the work now.
- An engineer can supervise five workstreams in parallel. They're not context-switching between five tasks. They're supervising five agents.
At Orbit, my team abolished story points, moved from Scrum to Kanban, and started measuring AI-based PR scoring (output per unit of human time, not human effort per feature). Every decision follows from the bottleneck flip.
The Two Harnesses
Most teams approach agentic development as a tooling problem: get the right models, configure Cursor, write a CLAUDE.md. This is the agent harness — the small loop that makes individual agents effective:
- Context engineering (system prompts, CLAUDE.md, glossaries, golden examples)
- Architectural constraints (linters, structural tests, CI gates)
- Verification infrastructure (type checks, visual regression, agent self-check)
- Automated garbage collection (freshness audits, pattern compliance checks)
Most teams fixate on the agent harness. The human harness is where the real transformation happens — and where most teams stall. The human harness is the big loop: how the team organizes itself around the fact that humans are no longer the ones writing code.
- Process model (how you run work when agents produce code in minutes)
- Work formats (tickets for grunt work, mission-style PRDs for feature work)
- Metrics (flow metrics, not velocity; harness health, not story points)
- Roles (PM, engineer, and agent responsibilities shift)
You can have perfect context files and still fail if your process still assumes humans write all the code. The agent harness makes agents effective. The human harness makes the team effective at working with agents. Both are required. Most organizations only build the first one.
Who Is an Agentic Engineer?
Not an AI/ML role. Not a prompt engineer. Not a “vibe coder.” The distinction matters because the market conflates them, and they command very different rates for very different reasons.
An agentic engineer has five core competencies that traditional software roles don't teach:
1. Context engineering
Writing system prompts, CLAUDE.md files, architectural decision records, and agent-readable documentation that consistently produce correct output. Bad context = correct implementation of the wrong thing, faster.
2. Harness design
Building the constraints, CI gates, and verification infrastructure that make agent output reliable at scale. The walls matter more than the model — Stripe's key insight.
3. Spec precision
The ability to define problems with enough precision that an agent can implement them correctly. This is harder than it sounds. Most developers have never had to make their mental model explicit enough for a non-human executor.
4. Architectural judgment
Knowing what to build, in what order, with what constraints — before the agent starts. Agents amplify judgment, not direction.
5. Outcome evaluation
Reviewing agent output isn't reading code line-by-line. It's evaluating whether behavior matches intent, whether edge cases are handled, whether the implementation fits the system. A different cognitive mode.
The result is a two-tier market. Roles requiring these competencies — real agentic engineering with production accountability — command significantly higher compensation than roles where AI is a productivity add-on. The gap exists because supply is thin and the skills are genuinely new. Nobody has even a year of real experience. The field has only been real since late 2025.
Evidence from Production
This isn't a prediction. The transition is already happening at the companies you know by name.
Stripe
Merges 1,300 agent-written PRs every week. Their finding: constraints, not model intelligence, drive reliable output. The walls matter more than the model.
Uber
90% of engineers use AI daily, saving 1,500 developer hours per week on code review alone. Some engineers produce 100% of their code through AI.
Cursor
35% of internal PRs are created by fully autonomous agents. Michael Truell (CEO) calls it “building the factory that creates your software.”
Zapier
97% AI adoption across the entire organization.
Senior engineers
See nearly 5x greater productivity gains from AI than juniors — because agents amplify judgment, not keystrokes. Experience still matters. It matters more.
Logistica OS
A logistics startup. Zero tickets, zero sprints, zero hand-written code. The CTO (10+ years in agent tech) hasn't coded by hand in months. 60,000 lines in two weeks. “Velocity is not the bottleneck — understanding the problem is.”
The pattern across every case: the constraint moves from “can we build this?” to “should we build this, and did the agent build it correctly?” That's the Bottleneck Flip in production.
The Tools
Agentic engineering isn't tied to a single tool. The landscape is moving fast, and serious practitioners use several in combination depending on the task.
Anthropic's terminal-native agent. Reads your entire codebase, edits files, runs commands. Particularly strong for complex multi-file refactors and architectural work. Built for the long-context, agentic loop model.
OpenAI's cloud-based coding agent. Runs in the background, handles tasks asynchronously. The “factory” model: submit a task, return to find it done.
The IDE that redefined the category. Deep codebase awareness, inline agent interaction, and (as of Cursor 2.5) cloud agents and async subagents that operate without the editor open. The most widely adopted tool among professional agentic engineers.
The enterprise standard. Deeply integrated into VS Code and GitHub workflows. Copilot Workspace brings agentic task completion to PRs and issues. The safest enterprise procurement choice.
Codeium's IDE-native agent. Direct competitor to Cursor, with a focus on multi-file flows and a cleaner UI for agentic interaction.
None of these tools makes someone an agentic engineer. The tools are the easy part. The hard part is building the harness around them — the context, constraints, and verification infrastructure that make agent output reliable in a production codebase.
How Companies Hire Agentic Engineers
Most companies don't know what they're looking for yet. Job descriptions say “AI experience required” and mean “have you used ChatGPT?” This misses the actual competency gap.
When Freightos (a publicly traded freight platform) hired me specifically to teach their engineering team agentic development practices, the engagement wasn't about tooling. It was about restructuring how the team works: QA strategy for agent-generated code, review tiers, CI/CD guardrails, context engineering. That's what agentic engineering consulting actually looks like.
What to look for when hiring:
- Evidence of production deployments, not demos. Has the candidate shipped real software using agentic methods? Ask about the verification strategy they used.
- Context engineering examples. Can they show you a CLAUDE.md or system prompt they've written? What does their agent setup look like?
- Process change experience. Have they changed how a team works, not just how they personally work? The human harness is an organizational question.
- Honest evaluation of failures. Experienced agentic engineers have war stories about agents confidently building the wrong thing. How do they prevent it?
Traditional interview loops don't test for any of this. Whiteboard coding tests and LeetCode exercises evaluate skills that agents now handle. Forward-thinking companies (Airbnb's Tolan team, for example) are redesigning interview loops where candidates use AI tools and are evaluated on judgment — “you own the output” — not implementation speed.
We've published a complete interview guide with 9 questions and green/red flags specifically designed for this — from tool awareness to harness thinking to team restructuring. It works for non-technical interviewers too.
The companies doing this well treat agentic maturity as a filter, not a feature. They know whether they mean “we have a ChatGPT subscription” or “agents ship to production.” That gap is where this job board sits.
One More Thing
Agentic engineering isn't a trend that might not stick. The evidence is already in production at the companies setting compensation benchmarks. The question isn't whether this transition is happening — it's whether your team is positioned on the right side of it.
Share this article
Useful context for your team? Share it.
Looking to hire engineers who actually work this way? Post an agentic engineering role — it takes five minutes and reaches engineers who filter by the tools your team uses.
Browse current listings →