← Journal
12 November 2026 · 7 min read

How I Work as an Agentic Engineer

agentic engineeringaiworkflow

These days I write less code by hand than I ever have, and I ship more than I ever have. That sounds like a brag. It's really a description of a job that quietly changed shape.

I build with AI coding agents most of the day. (The tools are in the companion post.) This post is about the part that matters more: how I actually work with them, what I still do myself, and where it goes wrong.

I'm the editor, not the typist

The biggest shift is where my effort goes. It used to be typing, looking things up, and fighting syntax. Now it's three things:

  1. Deciding what to build. Clearly enough that someone else could build it.
  2. Taste. Knowing when something is right versus merely working.
  3. Review. Checking that what came back is actually what I asked for.
flowchart LR
    I[Intent<br/>what + why] --> A[Agent builds]
    A --> V{I review it<br/>in the real thing}
    V -->|not right| F[Screenshot +<br/>one-line fix] --> A
    V -->|right| S[Ship]

The typing moved to the agent. The judgement didn't move anywhere.

Screenshots are specs

My favourite discovery: a screenshot plus one line beats a paragraph of description.

While building this site, nearly every fix started that way. I'd screenshot the thing that looked off and write a single line like "the QR code looks off, fix it" or "remove these two posts." The agent can see exactly what I'm pointing at, and I don't have to translate a visual problem into words.

It works because describing UI is lossy. "The QR code looks weird" could mean ten things. A picture of it means one.

A screenshot of a broken QR code plus one line of feedback, and the agent's fixed version

Queue the next thing, don't wait

Agents take time. Instead of watching a progress bar, I keep going: while one task is running, I send the next request. Rename this. Fix that link. Write another post.

It's a lot like working with a fast junior engineer who never sleeps. You don't stand behind them while they type. You hand over the next ticket and come back to review.

Requests queueing up, flowing through the agent, and landing in my review column

The catch is that you need to stay organised. If you queue five things, you're responsible for checking five things.

"Push when done"

The most useful sentence I type is probably "push when done."

It hands over the whole loop, not just the code: make the change, verify it, commit, sync the content to the database, push, deploy. For this site, that meant an agent editing files, updating the CMS rows, and pushing to the branch that deploys to production.

That's a lot of trust, so it's earned per task. Small, reversible changes get "push when done." Anything destructive, like deleting posts, I say explicitly and specifically.

Case study: one model builds, another verifies

The project where this clicked was garage64 (live), a digital garage and peer-to-peer marketplace for 1:64 diecast cars. You photograph a car, and you get an AI-generated 3D model of it on your public garage page.

I had OpenCode set up the backend on a free DeepSeek model. Then I handed control to Claude with a couple of lines:

"Take over OpenCode and direct it yourself, including which model it uses."

"Build the frontend, and run a subagent to oversee the backend work and guide it where needed."

Me, Claude Opus building the frontend, an Opus overseer briefing and verifying, and OpenCode on DeepSeek writing the backend

The overseer was an Opus subagent with a very specific brief: don't write backend code yourself, drive OpenCode. Give one focused step at a time with acceptance criteria. If it loops on the same error twice, diagnose it and hand over the exact fix. And the most important rule: don't trust its "done". Verify it yourself.

sequenceDiagram
    actor Me
    participant C as Claude (Opus)
    participant O as Overseer (Opus)
    participant D as OpenCode (DeepSeek, free)
    Me->>C: take control, free models only
    C->>O: brief: drive OpenCode, verify everything
    par frontend
        C->>C: build the frontend
    and backend
        O->>D: one step + acceptance criteria
        D-->>O: "done"
        O->>O: typecheck, tests, read the diff
        O->>D: exact fix when it's wrong
    end
    Me->>C: judgement call: recheck it with Claude
    C->>C: re-verify, finish the backend, end-to-end test

What the cheap model produced in roughly 53 minutes, at $0: a Fastify API with auth, 12 route modules, order and listing services, an order state machine, 3D-model adapters, a job worker, 4 database migrations and 9 test files. Genuinely useful scaffolding.

What the expensive model caught:

  • An API that doesn't exist. OpenCode wrote the 3D-generation adapter against an invented REST endpoint. Claude read the real model Space's source, found the actual call sequence, rewrote the adapter, and proved it with a real run: two photos in, a textured 3D model back in 35 seconds.
  • A 500 that should have been a 400. Malformed JSON crashed the request instead of being rejected cleanly. The overseer wrote the exact fix into the next brief: strip the stray byte-order mark, return 400, and add a test.
  • An infinite fallback loop. If one 3D provider failed, the worker handed off to the other, and back again, forever. It created 92 failed jobs in about two minutes before Claude capped it at one try per provider.

Once the scaffold was in place, I made a judgement call: stop the cheap model there and hand the backend to Claude to recheck everything and finish it. The free model had got us to a working draft fast. The last stretch needed the stronger model's judgement. The run finished with a full end-to-end test through the real frontend: signup, the 18+ gate, grading, photo upload, publishing, browsing and buying, including a double-tap that correctly did not create a second order.

The backend kept growing from there:

xychart-beta
    title "garage64 backend: OpenCode handoff vs. today"
    x-axis ["Routes: handoff", "Routes: now", "Tests: handoff", "Tests: now", "Migrations: handoff", "Migrations: now"]
    y-axis "Files" 0 --> 25
    bar [12, 16, 9, 22, 4, 18]

The full product write-up, with the architecture, the 3D pipeline and the order state machine, is in the garage64 case study.

The lesson I took from it: use the cheap model for volume and the expensive one for judgement. And when the stakes go up, point the expensive one at audits. A day later I asked Opus agents to find every implicit state machine and security flaw. They found 8 security issues, including a rate-limit bypass and a race where two buyers could order the same car. Both were fixed.

Where it goes wrong (and how I catch it)

This is the honest part. Agents are fast and confident, and confident is not the same as correct. These are real things that happened while building this site:

  • "Done" that wasn't quite done. I asked for page transitions. They worked, but on a page refresh the animation played four times, because every chunk of the page loading in counted as a transition. The agent couldn't see that. I could, the moment I hit refresh.
  • Details it filled in itself. Writing up one of my projects, it added confident-sounding details my original notes never said. They had to come back out. Now I always check that claims trace back to a real source.
  • The wrong number in the wrong place. An animated banner said a QR scan took 25 seconds. The 25 seconds was the whole handover, from finding the person to giving them a T-shirt. The scan itself takes about a second. Context it couldn't know.
  • Low-quality shortcuts. It linked image thumbnails instead of the full-size photos, so everything looked blurry. Easy fix, but only once a human noticed.

And one where it got it right on its own: I gave it dashboard screenshots for a post, and it blurred real participants' names and emails before publishing without me asking. That's the behaviour you want, but it's still my job to check.

The pattern in all of these: the agent can't see what I see. It doesn't refresh the page like a visitor. It doesn't know which number mattered at the event. So the review step isn't optional. It is the job.

What I still do myself

  • Product decisions. What goes on the site, what gets cut, what tone a post has.
  • Looking at the real thing. In a real browser, on a real phone, with a real refresh.
  • Anything irreversible. Deleting, publishing personal data, anything with money or credentials.
  • Saying no. Agents will happily build whatever you ask. Deciding what not to build is still mine.

If you're a student starting out

  • Learn to specify. The clearer your ask, the better the result. Vague in, vague out.
  • Learn to review. Read the diff. Open the page. If you can't tell whether it's right, you're not ready to ship it.
  • Keep the fundamentals. You catch the four-times animation bug because you understand how pages load. Agents raise the ceiling, but only if you have the floor.
  • Start with small, reversible tasks and widen the trust as you go.

Agentic engineering isn't about typing less. It's about spending your attention on the decisions only you can make, and having the discipline to check everything else.