Software Engineering Is Not Dead: Agentic Workflow Design Is High-Level Programming
When a computer executes your design for a team of agents, you are programming it. The abstraction changed. The need for design, precision and verification grew.
Picture three programmers at work.
The first arranges a deck of punched cards and carries it to a computer. The second sits at a terminal, writing C. The third describes a workflow: turn a request into an issue, give it to a coding agent, test the result, send it to an independent reviewer, and release it only after it passes.
The third is me. My instructions live in a repository. Computers execute them. When the system gets stuck, I change its instructions, its tools or its control flow, then run it again.
That is programming.
AI has disrupted software engineering so thoroughly that doing it now can feel like a different profession. A capable agent can search a codebase, implement a feature, run tests, investigate failures and revise its work. I can work at the level of whole projects and teams of agents. The leverage is extraordinary. But the continuity matters just as much as the disruption: agentic workflow design is high-level computer programming.
Calling it programming is more than a defense of a job title. It tells us how to do the work well. A workflow needs interfaces, state, error handling and tests. Its failures deserve debugging. Its author remains responsible for what it does.
We Have Climbed This Ladder Before
Punch cards were a medium, not a programming language. You could punch machine instructions or a high-level language onto them. The important transition was the level at which people expressed their intent.
Machine code specifies operations in the processor’s encoding. Assembly supplies symbolic names. C lets you describe functions and data structures while a compiler handles instruction selection and much of the machinery beneath them. Dennis Ritchie’s history of C describes the gains in writing and understanding programs above assembler, while keeping abstractions grounded in the machine. Higher-level languages and frameworks let you work in larger concepts again: collections, requests, transactions, pages. An agent workflow raises the level to tasks that themselves require reasoning and many tool operations.
The earlier advances were already attempts to make computers do programming work. John Backus and his colleagues called their 1957 paper “The FORTRAN Automatic Coding System”. Its introduction describes reducing the work of preparing scientific problems for the IBM 704 by having the machine produce programs that could compete with hand coding. The authors also had to make the resulting programs efficient enough to be worth using. Abstraction had to earn its place.
Delegating the translation did not make the scientist’s formula cease to be a program. Delegating more of the implementation does not make my workflow cease to be one, either.
There is a long history of promising that automation will finish the job. In No Silver Bullet, his 1986 technical report, Fred Brooks was already examining decades of automatic-programming ambitions. That history deserves more care than the convenient story that every new language was declared fake programming and every transition automatically created more jobs. What survives those promises is a harder, more useful question: which decisions did the tool actually remove, and which decisions moved up a level?
This Argument Has Company
I am joining an established conversation.
In Software 2.0 in 2017, Andrej Karpathy described a shift from writing explicit instructions to specifying goals and training neural-network weights. That was about learned programs, not today’s coding-agent workflows. His 2025 Y Combinator talk, Software Is Changing (Again), added Software 3.0: programming language models through natural language. The talk’s section on programming in English begins around 4:40.
Kent Beck makes the continuity particularly explicit in Augmented Coding: Beyond the Vibes: “Yes programming changes with a genie, but it’s still programming.” His account includes failed attempts, tests, intervention in the design and continuing dissatisfaction with unnecessary complexity. Simon Willison’s What Is Agentic Engineering? puts problem specification, tools, verification and iteration at the center of the work. Addy Osmani’s Agentic Engineering likewise argues for planning, code review, testing and ownership. These are practitioners’ arguments and experience, not controlled demonstrations of a universal productivity gain.
Nor is the idea that the arrangement of agents is a program waiting to be invented. The AutoGen paper, first posted in 2023 and subsequently published at COLM 2024, describes programming agent conversation patterns with natural language and code. Anthropic’s 2024 engineering account lays out prompt chains with programmatic gates, routing, parallel work, orchestrator-workers and evaluation loops. Steve Yegge’s Welcome to Gas Town goes further into a coding operation: worker roles, a merge queue, persistent work and workflow templates with dependencies, loops and gates. Those are close precedents for precisely this framing.
So what am I adding? An insistence on treating the whole working arrangement as a program you own, plus an inspectable example of running it on an actual repository. A list of impressive agent capabilities is less useful than a design that says who acts next, what evidence they must produce, what they may change and how the system recovers when they fail.
The Workflow Is the Program
Consider a rule in my coding workflow: the session that writes a pull request cannot be the session that approves it. Approval applies to an exact commit. If that commit changes, the old approval cannot authorize the new version.
That rule changes the behavior of a computer system. It determines which process may act, on which input, under which conditions. It is control flow and a constraint on state transitions. Some of it is expressed in instructions for agents; the repository tool enforces the parts that can be checked mechanically.
The familiar concepts are still there:
| Programming concept | In the agent workflow |
|---|---|
| Input | An issue describing the requested behavior and observable acceptance checks |
| Process | A running agent session or worker |
| Function or module | A role with a defined responsibility, procedure and interface |
| Scheduler | The queues, watchers and dispatchers that choose and continue work |
| Exclusive ownership | A claim that keeps two workers from taking the same assignment |
| Assertion | A test or review gate that must pass before the next transition |
| State and persistence | Commits, claims, delivery receipts and recorded decisions |
| Exception handling | Recovery for an operational failure, or a deliberate stop for a human decision |
These are correspondences, not claims that a role prompt has the exact semantics of a pure function. The point is that we can reason about the system using programming concepts because we are designing an executable system.
An organization chart on a wall does nothing by itself. A workflow that a dispatcher and agents execute continues work, rejects transitions, preserves state and produces artifacts. It can have a race condition. It can acknowledge a message too early. It can leave a task waiting forever. Calling those failures organizational problems does not make them less like bugs.
The new primitive is a capable agent. A single instruction can ask it to investigate a failure and produce a tested repair, with thousands of lower-level decisions inside that operation. I compose those operations into a larger machine. The language is natural language plus structure: role instructions, task records, tool interfaces, executable guards and feedback.
This also explains the scale of the opportunity. I can specify a process that carries out many implementations without specifying each implementation myself. One change to the shared workflow can improve how every subsequent task is handled. The expansion in what I can direct feels like orders of magnitude. That is a statement about my scope of control and experience, not a measured multiplier for every engineer or every task.
Astrohacker Is an Example You Can Inspect
Our repository rules define the roles and their authority. The skills define how each role works. The repository tool implements claims, queues, review gates and delivery records. This is our own operating design and experience, not a benchmark of other teams.
The issues session helps turn my requests into issues. Code and review controllers dispatch workers, one assignment per worker. Each coding worker keeps its claim through revisions; its reviewer stays with the pull request through the review rounds. Code and review run in separate sessions. The deploy role releases eligible merged changes under its standing authority. The image role makes art through its own workers and independent review. Actual product, copy, visual and other reserved decisions still come to me; ordinary operational failures are the agents’ job to resolve.
This post followed the same path. It was filed as a research-and-writing issue. An image worker made the Day and night covers, and its pull request merged before the writing began. A coding worker researched and wrote the article beside those covers. The writing must pass a separate reviewer before our tool will merge it. Publication follows the deploy workflow. The hands-on swarm guide explains the wiring as it stood when I wrote it; the repository is the current specification.
The failures are instructive, too. We had a collision between a direct assignment and a dispatched worker under the same identity. The repair distinguished their execution contexts so they could not write side by side. We also had completed workers occupying dispatcher capacity while cleanup remained pending. The repair separated completed work from pending cleanup while preserving its ownership and artifacts.
I did not solve those failures by personally doing all the agents’ work. We changed the program that organizes their work. That is the level at which much of my engineering now happens.
Precision Still Has to Live Somewhere
Edsger Dijkstra’s On the Foolishness of “Natural Language Programming”, EWD 667, supplies a serious objection. Formal notation gives us rules for manipulating statements precisely; a broader, more conversational interface can increase the burden of communication instead of reducing it. Making a request easy to say does not make its meaning unambiguous.
I agree with that warning. “Make this good” is a poor specification in English, and translating it into a hundred lines of code does not improve the requirement.
An effective agent workflow narrows the interfaces. A worker gets a bounded task. Its output is a diff and evidence. Tests express concrete cases and invariants. Tool schemas constrain inputs. A separate reviewer challenges the implementation and the evidence. Executable checks bind the resulting verdict to a particular revision. When the system fails in a new way, we improve those instructions and checks.
Natural language supplies expressive reach. Structure and verification supply precision. The combination lets me describe intent at a high level without pretending that intent verifies itself.
Nondeterminism makes that distinction essential. An agent may produce different implementations on different runs, and two agents may share the same blind spot. An independent session is a useful separation of responsibility, not a mathematical guarantee of independent mistakes. Tests can miss cases. Reviews can be wrong. I still need observable results, limited permissions, recoverable work and a way to investigate failures. More capable primitives make disciplined verification more valuable.
What Remains the Engineer’s Job?
Matt Welsh’s The End of Programming, a 2023 Communications of the ACM Viewpoint, makes a stronger prediction than the disappearance of typing. He envisages trained AI systems replacing most conventional software, with people supplying examples, data and evaluation. That is an argument about the future, not an empirical finding that engineering has ended. Even in that future, deciding which behavior is wanted and how to evaluate it remains consequential work. I would still call designing that computational behavior programming.
Jensen Huang’s 2024 World Governments Summit remarks, as reported by NVIDIA, challenged the advice that everyone needs to study computer science. His formulation includes both “nobody has to program” and “everybody in the world is now a programmer.” I agree with the expansion of access. I disagree that easier access makes understanding computation irrelevant. Asking a computer to do more gives you more reason to understand what it will do when it is wrong.
Brooks’s distinction between essential and accidental complexity remains useful here. Agents can remove much of the labor of translating a design into an implementation. They can also help explore the design itself. But the relationships, constraints and tradeoffs that make a system difficult still have to be resolved. A model proposing a solution does not settle whether it is the right solution for the people who will use it.
Nor does calling this programming prove that a tool makes a particular task faster. METR’s early-2025 randomized study found that its experienced open-source developers took 19% longer when allowed to use AI on their own repositories. Its February 2026 follow-up reports that selection effects and measurement difficulties make the newer speedup estimates unreliable. Those are research results with specific settings and limitations. They are a reason to measure a workflow’s outcomes, not to substitute enthusiasm for evidence.
What about understanding the code? Delegation changes how I obtain understanding; it does not cancel the obligation. I can ask for an explanation, trace a critical path, inspect a diff, challenge a test or investigate a failure. When I cannot establish enough understanding to justify a change, the change is not ready. A thousand generated lines that nobody can defend are a liability.
And the craft? There is still enormous room for it in choosing the right problem, finding a simple design, making interfaces clear and devising tests that expose a subtle error. There is also craft in designing a workflow that makes those good decisions repeatable. I enjoy being able to spend more attention there. Handwritten code remains available whenever that is the right level to work at.
A More Powerful Language
There is an economic reason to be optimistic as well. In his 2024 note Optimism, Willison argues that cheaper production-grade software could create much more demand for it. That is the Jevons-style argument applied to software: lower cost can expand use enough to increase total activity. It is a plausible expectation, not a guarantee about employment or any particular career. I want to build the software that becomes possible when the cost falls.
We can now tell a computer to carry out work at a level that used to require a team of people translating our intent through many intermediate steps. We can program the process by which it designs, implements, checks and delivers a change. That is a profound improvement in the expressive power available to a programmer.
The engineering is in the choices that give that power a useful direction. Specify the behavior. Design the interfaces. Make failures visible. Check the result. Improve the system.
Software engineering isn’t dead. It just got its most powerful language yet.