What Is Agentic Engineering?

Written by

@IndyDevDan

Compute co-authors: Claude Fable 5, GPT-5.6 Luna, Deepseek V4 Flash

Agent Harness Used: Claude Code & Pi Coding Agent

"You're not writing the application anymore. You're building the agents that write it for you."

These are the names for what most engineers think are separate skills.

They're not.

They're a part of something, much... much... bigger...

These are all sub-skills under the new emerging role of software engineering:

Agentic Engineering

So, what is agentic engineering?

How is agentic engineering different from normal software engineering?

Is vibe coding the same as agentic engineering?

What are the levels of agentic engineering?

What are the limits of agentic engineering?

And most importantly: How can you become a top 20% Agentic Engineer?

These are all questions we'll answer in this zero hype, raw blog post.

There's a lot of noise (AI slop) in the Tech Industry.

This creates confusion and miscommunication, and it slows down your progress.

My goal here is to give you exactly what you need to know to understand and become a great Agentic Engineer.

I promise to not waste your valuable engineering time.

Here's exactly what you'll learn.

LET'S COOK

What is Agentic Engineering?

Let's answer directly.

"Agentic engineering is software engineering with autonomous software that can take actions on your behalf."

That's it... The definition is simple but the implications for your engineering career are massive.

Let's break down EXACTLY what we mean by 'autonomous' software.

By autonomous software, most engineers refer to the combination of a loop around a language model inside of a harness.

The AI Agent.

So at its core, agentic engineering is the simple combination of agents (autonomous software) and traditional software engineering (deterministic software).

It's the 'autonomous' software that completely changes things for engineers like you and me.

With the AI Agent, instead of writing the application by hand, you can now build the agentic layer of system prompts, user prompts, skills, tools, MCP servers, agent harness and more that all give your agents one incredible ability.

Your agent can take actions, just like you can.

At first, your agents take digital actions for you, calling tools, functions, applications just like you do.

But before you know it AI Agents will enter the physical world too. It's only a matter of time.

But Embodied AI, AGI, ASI, and all these AI Pilled Silicon Valley terms don't matter here. For us engineers, with our boots on the ground every single day, what matters is that we continue shipping valuable software.

And for us, the ground truth is this: software engineering has changed so we must change with it or get left behind.

That's why my focus is helping you master agentic engineering, so you can push your career, work and business to the next level.

So let's focus in on what makes agentic engineering so special, and how it's NOT so special.

There are TWO VERY IMPORTANT THINGS to know about agentic engineering.

Agentic Engineering Is Still Software Engineering

1. You're still software engineering. That part is not new. You still plan, build, test, review, document and maintain software. Agents are a new tool to help you engineer software, nothing more. The responsibility is still on you and me, the engineers, to leverage the tool properly. You, the engineer, take on the risk and receive the reward (or consequence) of shipping software.
2. You're now building with software that takes actions on your behalf. That part is VERY NEW and it changes the fabric of how software is planned, built, tested, documented, reviewed and maintained.

If you understand these two ideas, you will understand what agentic engineering REALLY MEANS.

Yes, you're still software engineering AND...

For the first time in history, your software can take actions on your behalf.

The vibe coding craze (thanks Andrej Karpathy) has convinced many engineers, investors, product managers, 'the media', and 'talking heads' that coding is dead and software engineering is dead too.

Let me say this loudly and clearly: Software engineering is FAR from DEAD.

We'll talk more about vibe coding vs agentic engineering in a moment, but I can't stress this enough.

No legitimate software business is going to allow a vibe coder to run their value generating software assets.

Coding is one thing, and yes agents can code better than 99% of all engineers.

But software engineering is about MUCH MORE than just writing code.

Agentic engineering is still software engineering. Agents are simply a new tool in your engineering toolbox that expands your role as an engineer.

Someone (you, me, other engineers) still takes the risk, the responsibility and the reward for the success or failure of what was shipped.

Okay so you now understand that agentic engineering is software engineering with agents that can take actions on your behalf.

If we're still software engineering that means it's critically important that you understand the new thing: Agents.

The next logical question is then: How do agents change what you spend your valuable engineering time on?

The Agentic Layer And The Application Layer

With traditional software engineering, you build the product. That was the job, that's where your hours went, and that's where the value was. Plan it, Ship it, maintain it, repeat.

Now the value sits one level up, inside a new layer that wraps your application and infrastructure code. The agents, prompts, skills, system prompts, agent harness, and agentic workflows that wrap your product are the things to focus on.

That's what's called:

The Agentic Layer

Imagine every codebase you touch having a unique agentic layer that operates the application layer on your behalf.

This is the massive shift from traditional software engineering to agentic engineering.

Agentic Engineers build the agentic layer that operates the application layer on their behalf.

Here's why that matters for your engineering. The application layer solves problems for your customer. The agentic layer solves engineering problems for you and your engineering team AND it compounds every time you run it (if you build it right).

The agentic layer is the highest leverage asset that can exist inside your codebase.

Why? Because the agentic layer can RUN your codebase.

"The best engineering teams now build the system that builds the system."

This is how agents change what engineers should focus their time on.

We're shifting from building the application layer to the agentic layer because the leverage we get from building agentic systems that operate on our behalf, vastly outperforms working on the application directly. (Side note: we're including infra, devops, app, database ops, and all traditional software engineering under the term 'application layer')

So the agentic layer is where your engineering time goes now. That leads us to the next key question:

How do you build an agentic layer that engineers the way YOU engineer?

The answer is the most important idea in this entire post.

Template Your Engineering

Remember, agentic engineering is software engineering with agents that can take action on your behalf. In order for them to take actions for you properly, you have to teach them how to. This is how the agentic layer actually gets built.

When you template your engineering properly you can do something no engineer before you could do.

You can teach your software to build just like you can.

(Side note: If you're noticing a repeat trend here - you're on the right track. Systems taking actions on your behalf is THE CORE value proposition of agentic engineering.)

What does template your engineering mean exactly?

It's the process of teaching your autonomous software (agents) how to build your software. That's the unlock. It's not sitting in the terminal aimlessly prompting back and forth. That's vibe coding (which we'll get to in a second).

When you template your engineering you encode your judgment, your plans, your tests, your coding, your reviewing to enable your agents to run for you without you in the room.

These agents live inside agentic coding tools. Some are closed source:

• Claude Code
• Cursor
• Devin

Others are open source, which hands you far more control over your own harness:

• Pi Coding Agent
• Codex
• OpenCode

With a few exceptions (Pi Coding Agent), these tools are largely the same. They give you terminal access to an AI Agent. Then they wrap the agent with UIs, skills, auth and subscriptions to get you building the way they think you should build.

My recommendation is to start closed source, and as you improve as an agentic engineer (we'll cover exactly how to improve below) take control of your agent harness with a customizable and extensible open-source tool like the Pi Coding Agent.

Whichever tool you pick, the opportunity is the same: you can template your engineering into your agents, and your agents run your engineering for you.

That's agentic engineering defined: software engineering with agents that take actions on your behalf, an agentic layer where they live, and your engineering templated into it.

But there's one more key idea you need to truly understand agentic engineering. It's a trend as old as software itself, and it explains why agents were always going to happen:

Engineers always move up the stack.

And the engineers who move first get first-mover advantage.

Moving Up The Stack

When engineers say "we've moved up the stack," what do they actually mean?

Moving up the stack means changing the tools we create value with to something simpler, more capable, and better at doing more with less. Every generation of engineers gets exactly one of these jumps if they're lucky.

punch cards → assembly → C → compiled and managed languages → scripting languages → English

What's distinct this time is that the level of abstraction made a massive leap out of programming languages entirely, into natural language. Every previous jump traded one syntax for a friendlier syntax. This one traded syntax for intent.

How? The language model enables a new level of translation: natural language, to code, to bytecode.

But notice something. Every move up the stack had machinery underneath it holding the new layer up. C had the compiler. Scripting languages had the interpreter.

So what's the machinery underneath English?

The Core Four: The Agentic Layer At Its Smallest

The language model, composed into an agent, exposed by an agentic coding tool. That is what enables agentic engineering. Claude Code was one of the first, but it will not be the last. Specifically, it's the Core Four that makes up the agent: Context, Model, Prompt, Tools.

The Core Four makes up a single agent which is technically the agentic layer at its smallest unit. Everything above it is composition. Change any one of those four and you change what the agent is capable of. That is the entire surface you tune.

Let's make the Core Four concrete because if you understand the Core Four you'll understand the agent:

• Context: what your agent knows. The files, docs, memory, and state it can see right now.
• Model: the intelligence. How well your agent can think, plan, and code.
• Prompt: the instructions. What you're asking for, and how precisely you've encoded it.
• Tools: the hands. What your agent can actually DO: read, write, run, search, ship.

Look familiar? Those trending labels from the top of this post map straight onto the Core Four. Prompt engineering tunes the prompt. Context engineering tunes the context. Harness engineering wires the model and tools together. They were never separate skills. They were the Core Four the whole time.

Master the Core Four and you can build, run, and scale agents in any codebase, in any domain, with any tool.

But this raises an uncomfortable question...

If the Core Four is all it takes to run an agent, and anyone can prompt an agent in natural language, is everyone a software engineer now?

That question has a name: vibe coding.

Agentic Engineering vs Vibe Coding

What is Vibe Coding Really?

A fundamental truth about these models is that they appear to let anyone who speaks English write code.

That appearance is exactly what created vibe coding. When the barrier to producing working software drops to a sentence, a lot of people walk through the door.

So what is vibe coding?

Vibe coding is when anyone can sit down, prompt an agent, and ship the code that comes out: without inspecting it, without knowing how it works, and without knowing why.

Let's be brutally honest here. A vibe coder never leaves the app layer. They didn't move up the stack because they can't. They have no expertise to recognize the application layer. They just handed the keyboard to something else.

And let me be clear: vibe coding isn't a bad thing. But it is a dangerous trap for engineers who think they're engineering.

Vibe coding is great for prototyping and ideating. Spin up a throwaway demo, test an idea, feel out a concept. Perfect.

But the second you want to scale a production, value-generating, defensible product, you have to move away from vibe coding and into agentic engineering systems.

Remember: anyone can vibe code. Only software engineers can agentic engineer. Your expertise is what allows you to build powerful agentic systems. (We'll break down how to scale your agentic engineering in a moment.)

Put simply: you want to rise with the ceiling of agentic engineering, not sink into the floor of vibe coding. You can do incredible, insane, engineering work when you agentic engineer systems that operate with you, and without you.

Vibe coding is the FLOOR of what's possible. Agentic engineering is the CEILING.

Vibe Coding vs Agentic Engineering

Vibe coding and agentic engineering sit on opposite sides of a spectrum of understanding, capability, and potential.

When you vibe code, you don't know how your system works, and you don't look. When you agentic engineer, you know how your system works so well that you don't have to look.

The difference is astronomical.

Agents got reliable enough that serious engineers stopped reading every line of what they produce. That is not a crack in the distinction. The difference was never about looking, it's about understanding. Looking is a tactic. Understanding is a position.

Not reviewing every line isn't vibe coding. Not being able to review is vibe coding.

There is a massive difference between generating code and maintaining software. A vibe coder can generate code. A software engineer can generate code and maintain software.

Anyone can generate code. It takes years to learn to maintain AND scale profitable software.

The Expertise Gap

Let's be precise about what actually separates the two, because it's not prompting skill. A vibe coder and an agentic engineer can sit down with the exact same agent, in the exact same tool, on the exact same day.

The separator is software engineering expertise.

Go back to the definition: agentic engineering is software engineering with agents that take actions on your behalf. A vibe coder has the agents. They're missing the other half of the definition, and the other half is where all the power is.

Your expertise is what turns an agent from a code generator into a system:

• System understanding. You know how your software works and why. You can point agents at the right problems and verify the work that comes back.
• Wiring up agents. You can build engineering agents that run your engineering work and product agents that run for your users, all wrapped around one product.
• AI developer workflows. You can hand your agentic system a formal spec and have it plan, build, test, review, document, and ship into an existing brownfield codebase.
• Recovery. And when any of it fails at three in the morning, your expertise is the only thing that gets it back up. Recovery is a skill that does not transfer through a prompt without the ability to debug and resolve.

Agents flatten who can produce code. They do not flatten who can engineer systems.

That's the scale difference. A vibe coder prompts an agent and gets an app. An agentic engineer wires up agents and gets a system that ships software, with them and without them. The impact difference isn't 2x or 10x, it's exponential.

So hear the warning inside vibe coding. If you do not move up the stack, you will be passed by someone with far less experience than you, using the right tool for the job. Software engineering has changed and you must change with it.

I only say this because I want you to win, and to win, you must evolve.

And if you're a vibe coder who wants to cross the gap, there's one on-ramp: learn software engineering. Skip it and you will always be blind to your own creation.

So that's the full spectrum: vibe coders standing on the floor, agentic engineers building toward the ceiling.

Which brings us back to the promise I made you at the top of this post: giving you exactly what you need to become a top 20% Agentic Engineer.

Becoming top 20% starts with knowing exactly where you stand. Because 'agentic engineer' isn't one thing either. Between prompting a single agent and running a software factory, there's a massive range of skill and leverage.

In other words: there are levels to this game.

Levels of Agentic Engineering

Vibe coding is the floor. Agentic engineering is the ceiling.

And between the floor and the ceiling, there's a ladder.

Every engineer working with agents today is standing on one of nine levels. Find your level and you'll know exactly what to learn next.

The first five levels are the agentic path: BASE, BETTER, MORE, CUSTOM, ORCHESTRATOR. Levels six through nine are where the path leads.

1. The Single Agent. One agent inside a closed source agentic coding tool, prompting back and forth on one small task. This is where everyone starts. Your agentic layer is one conversation deep.
2. The Better Agent. You tune your harness: skills, CLI tools, MCP servers, a sharpened system prompt. You do more work, in less time, for longer. This level introduces you to prompt engineering, context engineering, and harness engineering: one agent's worth of each.
3. Many Agents. You realize one agent is not enough. You learn multi-agent orchestration. Your primary agent delegates to subagents, each focusing its context window on one problem at a time. You also spin up multiple primary agents at once. This level pushes your prompt engineering, context engineering, and harness engineering to the next level, enabling you to run more and longer threads of work.
4. Custom Agents. Specialized agents per domain, per problem, per area of your codebase. This lets you scale your agents across LARGE codebases and LARGE problems. You give them memory and they become Agent Experts that learn and remember. Here, you append and overwrite the default system prompt of your agent to get the exact outcomes you're looking for. At this level the default agentic coding tools stop being useful for you. This is where templating your engineering pays off: some of your agents start outperforming you in their domain.
5. The Orchestrator. You reach a limit. You can't coordinate everything you've built anymore. So you build one agent to rule them all: a single interface into your agentic layer. You've prompt engineered the system prompt of your orchestrator to properly call the right custom agent at the right time. With your orchestrator agent, you reduce and delegate your context window and focus each agent on one problem. Instead of compacting, you delete agents, because your agents are specialized, efficient, and focused.
6. AI Developer Workflows (ADWs). You realize agentic engineering is software engineering WITH AGENTS. You bring back great traditional software engineering practices and patterns, and build around the software development lifecycle. You stop throwing everything into a prompt and start shipping through repeatable workflows of agents PLUS code: plan, build, test, review, document, ship. Validation agents check the work so you're not the only reviewer. You start with worktrees for parallel runs. Then you move to agent sandboxes to give your agents isolation, scale and autonomy. At this level you stop thinking about agents, and you start thinking about pipelines of code plus agents that ship reliably on the 100th and 1,000th run. At this level, you evolve from focusing on agents to focusing on systems of agents plus code.
7. The Software Factory. You step toward ZERO TOUCH ENGINEERING. Tickets in, tested software out, no human in the middle. Your agentic layer is large, vast, and ships 80-90% of work autonomously. Specialized ADWs for chores, bugs, features, and hotfixes sit behind a routing agent, each running in its own sandbox. You set direction and validate outcomes. The factory does the rest. When something goes wrong, you never solve the problem directly. You solve the system that generated the problem. This is the gold standard every agentic engineer should strive toward. At this level, your agents inside your ADWs inside your software factory PROMPT YOU when they need something. Not the other way around. Here, you build the system that builds the system.
8. The Dark Factory. A software factory 95% operated by your agentic system. It's dark because the agents you've built don't need lights to see, and humans rarely turn them on to see. This is ZERO TOUCH ENGINEERING productionized at such a high level that the system nearly operates itself. You only work ON the system, focusing mostly on maintenance, direction (alignment) and cost optimization.
9. RSI System: Recursively Self-Improving System. This is the edge. The idea is simple, the implementation is the trick. Here your software doesn't just take in inputs, it creates them on its own. An RSI System is a (highly intelligent) dark factory so completely aligned with your goals that it can think and act for itself. This requires the highest levels of templating your engineering. In fact, here you've gone beyond engineering, and you've encoded your judgment, taste and vision. The system improves itself and delivers value for you and your customers with zero intervention. Your software is alive, and it works while you sleep. It sounds sci-fi but it's not. The top AI Labs are chasing these systems as you read this.

Every level up, you hand more of the process of engineering to your agentic layer, and you scale your compute to scale your impact.

Notice what happens at level six: traditional software engineering reenters the picture.

And take the name literally. An AI developer workflow is exactly what it says: a developer workflow, the planning, building, testing, and reviewing work engineers like you and me have always done, enhanced with AI. Hence: AI developer workflow.

Here's the move that separates the highest levels from everything below them: you bring traditional software engineering back into the picture and combine it with your agents to get the best of both worlds.

Agents plus code beats agents alone.

Stack ADWs on top of each other, wire them behind a routing agent, and you get the software factory: a system that handles the tasks surrounding your product just like an engineer would.

When you reach this level of agentic engineering, you realize the flexibility, extensibility and customizability of your agent harness are essential for success.

You reach for agentic coding tools like the Pi Coding Agent over Claude Code. We broke down why Pi is the only true Claude Code competitor in this blog.

The Three Actors Of Value Creation

I have one more framework for your agentic engineering, because it's how you actually improve. At every level there are three actors of value creation in software: engineers, agents, and code.

• Code is the unsung hero. It's deterministic. It runs identically every single time. It costs zero tokens and it moves at light speed.
• Engineers set direction. You decide what's worth building and what "correct" means before anything runs. Agents don't know what good means for your product. You do.
• Agents cover the middle. They're the most flexible actor and the least reliable one.

Rank them honestly on reliability and you get code > engineers > agents. Which leads to the warning most people building with agents ignore: don't over-leverage on agents. It's easy to reach for an agent when a twenty-line script would be faster, cheaper, and deterministic.

The role of software engineering in agentic flows is deciding which of the three does the work. The higher your level, the more that decision IS the job.

So the ladder leads to a software factory that ships without you. Which raises the question every skeptical engineer is already asking:

Where does this hit a wall?

The Limits of Agentic Engineering

Let me be clear here.

There is no wall.

This is true on the macro level (tech industry) and the micro level (our daily agentic engineering).

Every smart engineer or pessimistic investor who has bet against LLMs or Agents has been wrong.

Not enough training data? SOLVED

Not enough efficient algorithms? SOLVED

Not enough energy? SOLVED

Not enough compute? WORK IN PROGRESS

Do not bet against technological revolutions. Ride the wave. You're still VERY early in the age of AI.

Get your first-mover advantage.

There are no limits in sight. Every limit agentic engineers have hit with agents so far has turned into the next step. You climb it the same way every time: the right combination of engineers, code, and agents. The general trend is: you add more code and agents first, and more engineers second.

With agentic engineering, the impact a single engineer can have on the success of their product is exponential. And every year agents improve, that impact compounds.

That has massive implications for individual engineers, for engineering teams, for SMBs, and for enterprises. The gap between an engineer who builds agentic layers and one who doesn't stops being a minor productivity difference and starts being a massive exponential gap.

With that being said, there are two ongoing constraints of agentic engineering at a micro level.

It's important you're aware of them so you can identify them and push through them when the time comes.

The Two Constraints of Agentic Engineering: Planning and Reviewing

• Planning and prompting at the start.
• Reviewing and validating at the end.

"You and I always show up at the ends."

If you're agentic engineering properly at scale, the middle isn't yours anymore, and that's the point, not the problem. The middle belongs to the agentic layer you built. Everything between those two points is negotiable, and every step you climb hands more of that middle over.

Let's make these two constraints concrete, because this is where most agentic engineers actually spend their time.

Planning is ideating and deciding what SHOULD be done. This is judgment. This is taste. This is product sense. No current generation agent knows what's worth building for your users or what 'correct' means for your product. You do. Most engineers underinvest in their plan and are forced to make up for it in review.

Reviewing is validating what WAS done. Correctness, testing, validation. Your agents produced the work. You decide if it ships.

As agents progress, and as YOU progress your agentic engineering, target your focus here: Planning and Reviewing. This is where your time and leverage concentrate.

Because here's the complete picture. At the macro level, with the right agentic engineering, agents have no limits. At the micro level, we are the bottleneck, specifically, planning and reviewing. It's where hands-on agentic engineering happens, day to day.

So there's no wall. You know the levels, you know the constraints, and you know where the real work lives.

Become an Agentic Engineer

You started this post with a stack of trending labels that sounded like separate jobs.

They were never separate jobs. They were sub-skills of one new role, and now you can see the whole thing.

The whole discipline compresses into four ideas.

• The agentic layer. You're not just writing the application anymore. You're building the agents that write it for you.
• The expertise gap. Anyone can vibe code. Only software engineers can wire agents into systems that ship. Your expertise is the multiplier.
• Three actors of value creation. Engineers, agents, and code. Your job is picking which one does the work.
• Two constraints. Planning at the start, reviewing at the end. That's where your time goes. The middle belongs to the agentic layer.

What Is An Agentic Engineer?

Let's come full circle.

An agentic engineer is someone who builds the agentic layer instead of only the app, and who still understands their system well enough to recover when it breaks and improve it when the next feature is needed. Every strong agentic engineer understands their product at the system level. Yes, code matters less than ever, but scalable architecture and systems are where valuable assets are made.

"Agentic engineering is software engineering with autonomous software that can take actions on your behalf."

Call it agentic engineering, AI agentic engineering, AI software engineering, or agentic software engineering. It doesn't matter. The label keeps moving. The work underneath it doesn't.

How To Become An Agentic Software Engineer

So, the question this post promised to answer: how do you become a top 20% agentic engineer?

The answer is not a leap, it's the ladder you now hold. Find your level. Climb one level. Then climb the next one.

If you're at level one, tune your harness this week. If you're already delegating to subagents, your next move is memory and specialization. If you're running custom agents, wire your first ADW. Every level is one move. The distance you cover across nine of them is categorical.

Here's what that picture is telling you. You only ever have one next level. Don't get overwhelmed by all the ai hype and the next '*** engineering' term. Focus on what's right ahead of you and KEEP LEARNING and KEEP THINKING.

Agentic engineering is a new skill that requires you to invest in yourself and learn new things. Focus on the next level directly above where you're standing and keep learning.

Every engineer reading this has the same opportunity available right now, and most will sit on it until next quarter. That's the mistake you can skip right now. Compounding doesn't care when you learned about the opportunity, it starts the day you make it.

Agentic Engineering is the opportunity and now that you know what it REALLY MEANS there's only one question left for you to answer...

Are you ready to become a great agentic engineer?

I have two resources that will accelerate your transition into the new role of agentic engineering.

The free on-ramp is FORGET Loop Engineering. Agentic Engineering is about THIS. Engineers that have been using agents should watch this to combine agents plus code to outperform either alone. Remember, agentic engineering is software engineering with autonomous software that can take actions on your behalf. This means practicing GREAT software engineering WITH agents. Agents plus code beats either alone.

And when you're ready to build the agentic layer for real, with the AI developer workflows, the custom agents, and the orchestration behind them, that's exactly what Tactical Agentic Coding was built for. It's the fastest path from level one, a single agent in a terminal, to level seven, a software factory you own that works for you.

Ready to level up your Engineering?

MasterAgentic CodingThe official course by @IndyDevDan

Watch: Forget Loop Engineering

Stay focused and keep building.

- Dan