DEV Community

Alexander Ertli
Alexander Ertli

Posted on Edited on

What is the unspoken truth of agentic engineering?

GitHub was supposed to be the first connector.

Three hours later, the agent had produced a UI, a backend, database migrations, documentation, deployment work, signed-off commits, and a marketing pitch.

So I asked whether we could now quickly map Linear events into the same event bus.

No, apparently. It had built a system around GitHub events. The database stored GitHub events. Linear would need another table and another implementation cycle.

We already had an event bus. The task was to build an event ingress with a trigger system around it: receive events from external services, map them into the shared system, trigger the appropriate work. GitHub first.

Not GitHub forever.

I showed the agent the specification and plan again. They explained what to build, how, and why.

The agent acknowledged that this was not what it had built.

Then it offered to redo it.

As if it could time-travel.

By my accounting, the run had burned millions of tokens and 35% of my weekly allowance. But the real cost was figuring out which code and deployments to discard, rolling back changes, and the workdays lost by the people receiving this apparently finished work.

Including the sanity of the engineer who had to assess the damage.

The “This is fine” meme, except the dog has already updated the release notes.


The obvious explanations

There are several obvious explanations for this. I worked through them in a long conversation with an AI assistant. Every time it offered one, I removed it.

Because I wanted to know what was left.

Bad prompting?

The specification was there. So was the plan. The acceptance criteria and the “What are we building” document were referenced as Markdown files in the prompt.

This is also why the standard requirements-gathering routine makes me nervous. Ask an agent to plan a whole product, and it returns five questions. You answer them, it starts working, and everybody behaves as though the decisions have been made.

They haven’t. You have answered the five questions it chose to ask. The other decisions will happen during implementation.

In this case, one of the most consequential decisions had already been made: use the existing event bus and make GitHub the first integration. The agent was not being asked to discover that architecture. It was being asked to preserve it.

Bad model?

A frontier model, with reasoning set to xhigh.

Bad harness?

A frontier lab’s own harness—the environment managing the agent’s tools and execution.

That does not mean the setup was perfect. It does mean this cannot be dismissed as somebody putting a weak model in a loop and being surprised by the result.

What makes the incident particularly annoying is that the agent could recognise the mistake when shown the documents again. It could distinguish the requested system from the implemented one.

It just hadn’t maintained that distinction while building.

Compaction and handovers are places I would investigate. A summary saying “GitHub persistence implemented; continue with integration” can make an earlier deviation sound like an approved decision. The next session works from that. More implementation accumulates. Another summary follows.

I am not claiming to have isolated the exact internal cause of this run. Having the right instructions available did not keep them authoritative.

You need a better sandbox.

Yes. Better isolation could have reduced the cleanup. That would have been useful.

But put the entire run in a perfect disposable environment. Nothing touches production. Every change can be thrown away with one click.

You still have a GitHub-specific application where a general event ingress should be.

The sandbox cannot tell you that. Somebody still has to notice.

And the feature does not have to be visibly broken for the implementation to be wrong. GitHub events can arrive and trigger things successfully. That tells you GitHub works. It does not tell you the first connector has been built as a connector.


Okay. Let another AI review it.

Then review the work properly.

Okay. Who does that?

The engineer receiving the deliverable?

Ask that person to repeatedly inspect large agent-generated changes, reconstruct the assumptions, compare them with the original intent, and take responsibility for the result.

Eventually, something predictable happens.

They paste the diff into Claude.

Now, the easy objection is that Claude might miss the same mistake. But let’s not take that exit.

Give Claude the original prompt, specification, and plan. Give it enough context. Assume it reviews properly and immediately flags the problem: this is a GitHub-specific implementation, not the reusable ingress that was requested.

It writes a good review. The implementing agent follows the instructions. Claude checks again. More corrections follow.

This part is a thought experiment, not a claim about how we recovered from the original incident.

And I will grant the strongest possible outcome: eventually, the agents produce a good implementation. Not merely something that satisfies a weak checklist. A genuinely acceptable implementation of the requested system.

Now what is the problem?


Make the costs disappear.

The tokens.

Yes, those review and reimplementation cycles can become expensive. The reviewer reads the requirements and code. The implementer reads the review and changes the code. Then the reviewer reads it again. Previously cached context may no longer be reusable. A correction can require substantial implementation work of its own.

But fine. Make tokens free.

The time.

Fine. Make that free too.

Assume we do not care how long the agents spend arguing on GitHub. They converge. The implementation is good.

Who wrote the original specification?

The human engineer.

Who gets pinged for final approval?

The same human engineer.

What do they find?

Potentially a hundred-plus commits, review comments, refactors, reversals, follow-up changes, and pages of discussion explaining why each change was necessary. Lots and lots of “engineering” around what began as a bounded integration task.

The person who understood the system well enough to specify the change now has to establish what happened to their system.

No, they do not need to read every abandoned commit. Squash the history. Show them the final diff. That helps.

It does not automatically make the final change small or understandable.

If the agents absorb all their own churn and return a clean, limited change that the engineer can readily understand, excellent. That is what we wanted. But when they hand the complexity back to the engineer, the work has not disappeared just because two models agree it is finished.

The engineer either reconstructs enough understanding to approve it meaningfully, or accepts the agents’ assessment.

The two-buttons meme: one says “Review 50+ commits.” The other says “Trust the AI reviewer.” The sweating engineer owns the consequences either way.

DORA’s March 2026 analysis of 1,110 responses from Google engineers describes this transfer of work: faster generation for the author can mean more auditing and cognitive load for the reviewer. The same analysis reports useful applications of AI. The improvement in one part of the workflow can create work elsewhere. DORA


Approved. Merged. Now what?

Now we need Linear.

Someone has to write that prompt against the implementation we actually have, not the one that existed in their head when they wrote the first specification.

Does the engineer understand the new interfaces? Where the mapping belongs? What the agents decided about persistence? Which behaviour is shared and which is provider-specific?

Perhaps they do. Perhaps the handover was good.

Or perhaps they ask an agent to explain what the previous agents built, then use that explanation to instruct the next agent.

That can work too. I am not claiming the next connector must fail.

I am asking where the organisation’s understanding of its own system now lives.

The engineer began this process knowing enough to specify a small architectural change. After implementation, review, reimplementation, approval, and merge, do they still know enough to direct the next one?

Or have we made them dependent on the same process both to change the system and to tell them what the system is?

That is what remains after we make the models competent, the reviews good, the tokens free, and the time irrelevant.

Not a proof that automation is useless. A question about what the organisation has actually acquired.

Working software, certainly.

Can it still own the software?

And before someone says the engineer should simply write an even more detailed prompt next time: how much of the engineering are we asking them to do in that prompt? Every architectural choice? Every future integration? Every customer requirement that does not exist yet?

We already had the relevant requirement for GitHub. More foresight would not have repaired a failure to follow it.


Change one thing: keep the engineer in the room.

Go back to the original run and change one thing.

Put the engineer who understood the plan in front of the screen while the agent works.

They see the first consequential departure and interrupt: why are we building a GitHub-specific system? GitHub is one adapter. We already have the bus.

Maybe the agent needs another correction later. Maybe the engineer needs to inspect the proposed data flow before allowing it to continue. I cannot prove exactly where that intervention would have happened.

But it need not involve reviewing a whole application. It can happen before the application grows around the wrong decision.

In my own work, the attention I give a run, together with how much execution accumulates between checks, has become a useful warning of the possible blast radius. Not a universal formula. Experience with the tool.

Which makes the comparison uncomfortable.

Same model. Same reasoning setting. Same harness. Same specification.

A knowledgeable person remains involved while the decisions are being made.

That person is not merely an emergency brake. They know which existing capability to reuse, which apparent problem does not require new code, and when the agent is turning an integration into a product.

The impressive solution might be a small amount of wiring into the existing system. Generating ten thousand lines instead is not evidence that ten thousand lines of work were needed.

If the useful setup is an experienced engineer actively steering an agent, that is still useful. Potentially very useful.

It is also a different proposition from an engineer writing a prompt, walking away, and returning to completed engineering.

And it changes what “scale it to ten agents” means.

Are we multiplying implementation capacity, or multiplying the decisions one person must stay sufficiently close to understand?


AWS is asking some of the same questions

AWS is useful here because its published guidance does not make that person disappear.

Its July 2026 framework recommends reviewed specifications, scoped tools, automated checks, a separate AI reviewer checking the implementation against the specification, and human approval proportionate to the risk. That is remarkably close to the improved workflow we just walked through. This is public AWS guidance, not a claim that every Amazon team has one identical internal policy. AWS Security Blog

The framework also warns that routing every change to a human invites approval fatigue: people begin approving by reflex. It retains developer accountability rather than treating the agent as the new owner of the consequences. AWS Security Blog

In October, Amazon’s engineering leadership published a memo accompanying revised developer-role guidance. It warned that using token consumption and code volume as targets could increase cost and complexity, and emphasised long-term outcomes. Amazon News

It also said:

If your work does not benefit from current AI tooling, that is a finding, not a failing.

This was in a memo strongly encouraging AI adoption, not abandoning it. Amazon was asking engineers to exercise judgment about where the tools help. Amazon News


What is the unspoken truth of agentic engineering?

So no, I do not think I have discovered something nobody else knows.

I think people doing this work are encountering a condition that gets omitted from the simpler business story: somebody still needs to understand what is happening, and keeping them informed is part of the work.

This is not a convenient finding for me. I would love to be able to sell the uncomplicated version.

But I cannot watch an agent build the wrong architecture from a correct specification, spend days dealing with the consequences, and call it a prompting lesson.

Nor can I solve the business problem by adding another agent to every place a human used to think, then quietly keeping an experienced engineer at the end of the chain to accept responsibility.

That engineer’s attention has to appear in the calculation.

So does the effort needed to keep their understanding current. So does the recovery work. So does the next feature.

An AI-first organisation may end up needing a higher concentration of senior judgment, not a lower one. If the humans are mainly handling ambiguity, architecture, intervention, and acceptance, we have concentrated the difficult work in those humans. Buying more execution does not settle how that work scales.

None of this means using AI to code is bad. It means replacing handwritten code with generated code is not, by itself, evidence of a competitive advantage.

Show the advantage across the work the business actually needs done.

For a disposable clone whose job is to get attention on Reddit once, the calculation may be completely different. Ship the thing. See whether anybody cares. There is nothing wrong with that objective.

Yet for production software that should run for years, evolve, and carry an organisation, getting the first screen working is not the whole assignment.

The unspoken truth of agentic engineering: it still needs a human in the seat. You can’t simply “scale by throwing tokens at the problem.”

With that person involved, the agent may be an excellent tool.

Top comments (1)

Collapse
 
gautamtalksdev profile image
Gautam K •

"GitHub first, not GitHub forever" is the sentence the agent needed before it started, not after three hours. What's helped in cases like this is writing the second integration into the task as a test from day one: "a Linear event must map into the same table with no schema change". The agent then can't build a GitHub shaped system, because that test fails. Did you end up rewriting it, or teaching the agent to refactor what it had?