
The System of Making Agents Work
The difference between an agent that ships software and one that wastes your time isn't always the model. It's the system you build around it.
I've spent almost two years writing software with AI agents, and one thing has become increasingly clear:
The difference between an agent that ships software and one that wastes your time isn't always the model. It's the system you build around it.
From February 2025 to November 13, 2026, I've experimented with nearly every major generation of coding models. From GPT-4o to GPT-5, GLM-4.5, Kimi K2, Claude Opus 4.5, Claude Fable 5, GPT-6 Astra, and finally Claude Fable 5.2.
I've watched the way we build software with agents change completely, and my own workflow has changed with it.
In the early days, we treated agents almost like people. We'd give them names, personalities, roles, tasks, and goals, then write elaborate prompts hoping they'd behave like the engineers we imagined them to be.
Looking back, it's interesting how much of our workflow was built around compensating for what the models couldn't do.
From writing functions to engineering entire systems#
When I started experimenting with coding agents, GPT-4o was one of the first models that made AI-assisted programming genuinely useful for me.
At the time, getting a model to write a good, usable function that you could actually trust after reviewing and testing it felt like a meaningful achievement.
You could describe a function, provide some context, and get something that worked.
But moving beyond that into larger codebases, complex changes, and multi-step development was a completely different problem.
A lot of the work still involved manually breaking tasks down, repeatedly explaining the same context, fixing inconsistencies, and making sure the model hadn't broken something elsewhere.
Then came GPT-5, GLM-4.5, and Kimi K2. I started expecting more than isolated functions. I wanted models that could understand existing codebases, reason through implementation decisions, use tools, and complete tasks without needing constant direction.
By the time I was working with Claude Opus 4.5, Claude Fable 5, and GPT-6 Astra, my expectations had changed significantly.
I wasn't just asking agents to generate code anymore. I was expecting them to investigate repositories, understand existing architecture, implement features, run tests, debug failures, and work across multiple parts of a system.
And now, with Claude Fable 5.2, the gap between what I originally expected from a coding model and what I expect from a coding agent has become enormous.
The interesting part isn't simply that newer models are more intelligent.
It's that the entire nature of the work we're giving them has changed.
My own account from the text above, read as steps. Not a benchmark.
Show the data
| Models | Unit of work | What that meant |
|---|---|---|
| GPT-4o | A function | Describe a function, give context, review and test what comes back. |
| GPT-5 · GLM-4.5 · Kimi K2 | A task in an existing codebase | Understand the codebase, reason through decisions, use tools. |
| Claude Opus 4.5 · Claude Fable 5 · GPT-6 Astra | A feature across the system | Investigate, implement, run tests, debug, work across parts of a system. |
| Claude Fable 5.2 | An engineering objective | Coordinated, integrated and verified work toward one objective. |
Writing code and completing a software engineering task are two very different things.
A model can generate a technically correct function and still fail to deliver a working feature. It can implement exactly what you asked for while completely misunderstanding how that change fits into the rest of your application.
Better code generation doesn't automatically translate into better software engineering.
And as the models improved, I gradually stopped focusing exclusively on how much code they could write and started paying more attention to how the work itself was being managed.
The shift from prompt engineering to systems engineering#
The old approach worked to an extent, but it had a ceiling.
As agents became more capable and more real software started shipping through them, the bottleneck shifted.
It was no longer just about getting a model to understand what you wanted. It was about giving it the right environment, context, constraints, tools, and processes to actually deliver.
We moved from writing better prompts to designing better systems.
One of the biggest changes in my workflow was moving toward specification-driven development.
Instead of giving an agent a loosely defined task and hoping it understood what I meant, I started paying more attention to defining the actual requirements.
What exactly needs to be built? How should it behave? What existing functionality must remain untouched? What constraints does the implementation have to respect? And most importantly, how do we determine whether the work is actually complete?
These questions sound obvious, but they're surprisingly easy to ignore when working with a model that can generate hundreds of lines of convincing code in seconds.
At the same time, the architecture of agentic workflows was evolving.
We went from single agents handling everything inside one conversation to systems where a main agent could coordinate multiple subagents, distribute work, and execute tasks in parallel.
And this is one of the developments I find most interesting.
Modern agentic development isn't simply about opening multiple conversations and assigning different prompts to each one.
Agents can work with shared project context, coordinate their tasks, communicate progress, and operate in isolated Git worktrees without interfering with one another's working directories.
One agent can investigate an existing architecture while another implements a feature. Another can build the corresponding tests, while a separate agent reviews the implementation or investigates a dependency.
The main agent coordinates this work, manages dependencies, and brings the results together.
Git worktrees make parallel development practical by allowing agents to operate on separate branches and working directories. Shared context and structured communication allow them to work toward the same specification without requiring every agent to rediscover the entire project.
This makes it possible to approach software development as a coordinated execution process rather than a sequence of isolated prompts.
The important change isn't just that we can run more agents.
It's that we can design systems where multiple agents contribute to the same engineering objective, with their work coordinated, integrated, and verified.
Context engineering has also become a major part of this shift.
Earlier, a common approach was to give a model as much information as possible. More documentation, more instructions, more conversation history, and increasingly elaborate system prompts.
But more context isn't necessarily better context.
What matters is how information is organized, retrieved, shared, and maintained throughout execution.
An agent investigating a database schema needs different immediate context from one implementing a frontend component. Both may need access to the same architectural decisions and project requirements, but they don't need identical working context at every moment.
A good system makes relevant information available when it's needed, preserves important decisions, and allows work to continue without repeatedly reconstructing knowledge.
This becomes especially important when agents are operating in parallel across different parts of a repository.
Specifications, repository knowledge, task state, execution results, and verification feedback all become part of the system's context.
And what people now call vibe engineering has started moving beyond simply describing an idea and watching AI generate code.
For me, the interesting part is how all these pieces come together.
The prompt is still important, but it's no longer the entire workflow.
A well-written prompt cannot compensate for missing requirements, unreliable tools, poor context management, or a system that has no way of verifying its own work.
More intelligent agents don't automatically mean better software#
But there's a problem I keep seeing.
We've become obsessed with how intelligent our agents are, while paying far less attention to how effectively they work.
Every new model release brings another round of benchmarks, comparisons, and claims about which model is the best at coding.
And I pay attention to them too.
I've spent nearly two years moving between different models, testing their capabilities, adjusting my workflows, and figuring out where each one actually performs well.
From GPT-4o to Claude Fable 5.2, the improvement in model capabilities has been remarkable.
But one lesson has remained consistent throughout that experience.
A model performing well on a benchmark doesn't automatically mean it'll perform well inside your development workflow.
A powerful model with a poorly designed workflow can still produce terrible software.
It can misunderstand requirements, make unnecessary changes, introduce regressions, or confidently declare a task complete when it hasn't met the specification.
You can have one of the most capable models available and still spend hours correcting work that should have been completed properly the first time.
And sometimes, switching to a more powerful model doesn't solve the underlying problem.
Because the issue isn't always intelligence.
Sometimes the specification never clearly defined the expected behavior. Sometimes the agent didn't investigate the existing implementation before making changes. Sometimes relevant project knowledge wasn't made available during execution.
And sometimes the system simply had no meaningful definition of done.
This is where I think the distinction between a capable model and an effective agentic development system becomes important.
A model's intelligence determines a great deal of what it can accomplish, but the execution system determines how that capability is applied.
If an agent is expected to implement a feature, the system should provide access to the repository, the requirements, the relevant tools, and a way to verify the implementation.
If multiple agents are working on the same project, the system should coordinate their execution, maintain shared knowledge, manage dependencies, and integrate their work.
If an implementation fails its tests, that failure should become part of the agent's feedback loop rather than the end of its execution.
And if a task is considered complete, that conclusion should come from actual verification rather than the model simply saying it's finished.
The point isn't to replace reasoning with rigid processes.
It's to build an environment where an agent can apply its reasoning effectively and where the results of that reasoning can be tested.
From prompting agents to engineering their execution#
Something else changed as I moved through these different generations of models.
I became less interested in treating prompts as the main unit of engineering.
In the early days, a lot of effort went into constructing the perfect instruction.
We told models to act like senior engineers, think carefully, follow specific roles, and avoid making mistakes. We built increasingly elaborate prompts around behaviors that we wanted to encourage.
But the quality of an engineering workflow can't depend entirely on how convincingly we describe those behaviors.
A system that expects agents to test their changes should give them the tools and execution environment to run those tests.
A system that expects agents to understand an existing codebase should let them explore it, search through it, and inspect its dependencies.
A system that expects agents to collaborate should support coordination, shared context, parallel execution, and integration.
And a system that expects reliable software should establish a process for checking correctness.
This is also where specification-driven development becomes much more useful.
A specification isn't just a long document explaining what an agent should build.
It can become the reference point for task decomposition, implementation, testing, review, and acceptance.
Agents can derive work from it, coordinate around it, and compare their results against it.
Instead of relying on a conversation that gradually accumulates requirements and decisions, the system can maintain a clearer representation of what needs to happen and what has already been completed.
When combined with parallel agent execution, shared context, Git worktrees, and automated verification, this begins to look much closer to an engineering execution environment than a chatbot generating code.
And that's the direction I think matters.
Making agents work is becoming its own engineering discipline#
After nearly two years of experimenting, I've come to believe that making agents work reliably is a discipline of its own.
Not just prompt engineering. Not just context engineering. Not just giving an agent more tools or spawning more subagents.
It's about designing the entire system through which an agent understands, plans, executes, coordinates, verifies, and completes work.
That includes how specifications are written, how context is managed, how tasks are decomposed, how agents communicate, how work is distributed across branches and worktrees, how changes are integrated, and how correctness is established.
- The prompt
- The system around it
Each block is one part you design. The list is the one from the closing section.
Show the data
| Workflow | Part | What it covers |
|---|---|---|
| Early workflow | Prompt | The prompt: names, roles, personas, instructions |
| Now | Prompt | The prompt, still important |
| Now | Specification | How specifications are written |
| Now | Context | How context is managed |
| Now | Decomposition | How tasks are decomposed |
| Now | Communication | How agents communicate |
| Now | Worktrees | How work is distributed across branches and worktrees |
| Now | Integration | How changes are integrated |
| Now | Verification | How correctness is established |
It also means thinking about the complete development lifecycle rather than treating code generation as the final objective.
An agent that writes an implementation but never tests it hasn't necessarily completed the task.
An agent that passes a few tests but violates the project's architecture hasn't necessarily delivered a good solution.
And an agent that produces a large amount of code isn't automatically more productive than one that makes a smaller, correctly scoped change.
I think this is where much of the next improvement in AI-assisted software development will come from.
Models will continue to become more capable. Context windows will grow, reasoning will improve, tool use will become more sophisticated, and parallel agent execution will become more deeply integrated into development environments.
But those improvements become much more valuable when they're supported by systems designed to turn capability into reliable execution.
After moving from GPT-4o through GPT-5, GLM-4.5, Kimi K2, Claude Opus 4.5, Claude Fable 5, GPT-6 Astra, and now Claude Fable 5.2, that's the biggest change in how I think about working with coding agents.
I'm no longer just interested in what a model can generate.
I'm interested in how much real engineering work an agentic system can complete, how reliably it can complete that work, and how little manual intervention is required to get there.
The goal isn't to make an agent write more code. It's to make it complete more work correctly, with less intervention.
And that's what I want to break down next: the lessons I've learned, the approaches I've abandoned, and the system I now use to make coding agents actually work.
Sources#
- Models, in the order I used them: GPT-4o and GPT-5 (OpenAI), GLM-4.5 (Z.ai), Kimi K2 (Moonshot AI), Claude Opus 4.5 (Anthropic), Claude Fable 5 (Anthropic), GPT-6 Astra (OpenAI), Claude Fable 5.2 (Anthropic).
- Git worktrees: git-worktree documentation.
- Subagents: Claude Code, Create custom subagents.
- Context engineering: Anthropic, Effective context engineering for AI agents (September 29, 2025).
- Vibe engineering: Simon Willison, Vibe engineering (October 7, 2025).
- Specification-driven development: GitHub, Spec Kit.
- Coding benchmarks: SWE-bench.
