Von Jason Lagare
17 November 2026

The slow part was never the typing

What 108 days of building with an AI teammate taught us about the job.

Imagine a job ad.

Now hiring: Senior Confident Engineer Context: none. Confidence: 100%. Correctness: TBD.

Would you hire them?

We did. And on the first day, it told us this:

$ agent status
✓ done! all tests pass

$ agent tests --count
0 tests run

Fast. Never tired. Knows nothing about your company. Says “done!” with total confidence, even when it isn’t.

That’s an AI coding agent, described honestly. We hired it anyway, and 108 days later we shipped a B2B enterprise platform that didn’t exist when we started — around 40% ahead of a six-month plan, with about ten engineers.

This is what we learned, including the parts that didn’t work.


The deal we made with it

The operating model fits in one sentence: the agent drafts, a human decides.

In practice the agent did a lot of drafting. It read the ticket, planned the work, wrote the code and the tests, scanned its own output for vulnerabilities, updated the documentation and release notes, opened the merge request, and prepared the release.

Humans kept three decisions, and only three:

  • What to build. Approving the story, answering the agent’s questions about it.
  • Whether it’s good. Reviewing every change before it merged.
  • Anything we couldn’t undo. Saying “go” before a push, a merge, or a release.

That split matters more than it sounds. The temptation when you adopt agents is to gate everything — every step, every file, every command — on the theory that more oversight is more safety. It isn’t. It’s just slower, and reviewers who are asked to approve forty trivial things stop reading carefully by the eighth. Gate the irreversible, not every step.

The other half of making it useful was giving it hands. An agent that can only talk is a very expensive autocomplete. Connected to our actual tools — the issue tracker, the repository, the security scanner — it could do the whole loop instead of handing us homework at every stage.


Everyone writes the playbook

The agent is only as good as the setup around it, and that setup is not a config file somebody owns. We ended up with four kinds of shared material:

  • Rules — what it must always do, and never do.
  • Skills — how we do a particular task here, step by step.
  • Sub-agents — a specialist for one job.
  • Workflow — how it all fits together, from ticket to release.

The important decision wasn’t the taxonomy. It was that anyone could write one, and everything was shared by default. An engineer who worked out a better way to get the agent through a tricky integration wrote it down once, and from then on every agent on the team had it. Free to build, shared by default.

This is the part most teams skip, and it’s the part that compounds. The agent doesn’t get better on its own. Your setup around it does.


Three lessons that cost us

1. Make it show you

Remember “all tests pass,” with zero tests run.

That wasn’t a one-off. A language model will report success in the same confident register whether it succeeded or not, because the thing it is good at is producing plausible text, and “done, all tests pass” is extremely plausible text.

The fix is a rule, and it’s the single most valuable one we adopted: no claim without evidence. Not “did it work?” but “show me the output.” The agent doesn’t get to assert that the tests passed. It has to produce the run.

This generalizes well beyond AI, which is probably why it stuck.

2. Onboard it

The bugs that cost us the most weren’t inside a service. They were between services — the boundaries where one team’s assumption met another’s.

The agent couldn’t see those, because nobody had written them down. So we wrote them down: the architecture, the contracts, the decisions behind them, aimed at the agent as the reader.

Those turned out to be the best docs we had. Writing documentation for a reader with no context, no social cues, and no ability to tap a colleague on the shoulder is a surprisingly effective forcing function. New human engineers liked them too.

3. Keep changes small

The typical merge request we shipped was a single commit. Across more than 1,100 of them, 90% were merged within a day.

That’s not a productivity stat, it’s a review stat. Small changes are what make fast review possible, and fast review is what makes the whole loop safe. The moment an agent can produce a 2,000-line change in ninety seconds, “keep changes small” stops being style advice and becomes the thing standing between you and an unreviewable pile of plausible code.


Speed only helps if you point it at the right thing

Here’s the equation we kept coming back to.

Clear requirements — acceptance criteria you can test, edge cases and examples, what’s out of scope, a definition of done.

Plus the right context — architecture and API contracts, coding standards expressed as rules the agent reads, linked stories and past decisions. And only what’s relevant: too much context degrades the result as reliably as too little.

Equals the right result the first time — fewer review loops, and far fewer “bugs” that turn out to be misunderstandings.

Invert it and you get the failure mode: a vague story plus missing context produces a confident wrong answer, fast. Correctness: TBD.

Most of the time an agent disappoints you, it is not because the model is weak. It’s because it was asked to guess, and it guessed confidently, which is the only way it knows how to guess.


The lesson that isn’t about AI at all

The agent writes integration code in minutes. It cannot give itself API access, a sandbox, test data, a firewall rule, or a security sign-off.

People do that.

Our integrations touched systems owned by other teams, each with their own gatekeepers — system owners, the gateway and integration team, security and platform, identity. What actually moved the needle was embarrassingly unsophisticated:

  1. Name one contact per system, on day one.
  2. Ask for access in week 1, not week 8.
  3. Turn their answers into docs the agent reads.
  4. Bring them the demo, not just the request.

That last one is worth dwelling on. People who are asked for access give you a queue position. People who are shown a working thing that needs one firewall rule give you the rule.

AI speeds up the code. The right people speed up everything around it.


Once building got fast, the bottleneck moved

This is the part I didn’t expect.

We started using the agent for code. Then it spread downstream — tests, security scans, documentation, release notes. Then it spread upstream, which is the direction nobody plans for: requirements, design, diagrams, briefings for the business.

Same teammate. Same rule: it drafts, a human decides.

And that’s when the shape of the job became visible. When writing code stops being the constraint, the constraint becomes everything around it — deciding what to build, giving the work enough context to be done right, and judging whether what came back is actually good.

The slow part was never the typing. It was the deciding.


What the engineer’s job becomes

Four things, and all four are senior skills:

Set the intent. Turn a story into a clear goal, and answer the questions the agent raises about it. Vagueness that a human colleague would quietly resolve becomes a confident wrong answer here.

Shape the context. Write the docs, rules and skills the agent reads. Share what works. This is the highest-leverage work on the list and the easiest to skip.

Review with evidence. Judge output like a senior reviewer. No proof, no merge.

Own the decisions. Architecture, trade-offs, and anything you can’t undo.

Less typing. More thinking, reviewing and deciding.

I’ll say the obvious thing about juniors, because people ask: this is not bad news for them. The engineers on our team who grew fastest were the ones reviewing real changes every day. Reviewing is how you learn judgment, and they were doing a year of it in a month.


Steal these

Seven rules, none of which are AI tricks:

  1. Gate the irreversible, not every step.
  2. No claim without evidence.
  3. Give it hands — connect your real tools.
  4. Feed it clear requirements and the right context.
  5. Keep changes small, and the process smaller.
  6. When code gets fast, take it beyond code.
  7. Line up the right people early.

Read them again and notice what they are. Clear expectations, evidence over assertion, small units of work, good onboarding, the right people involved early.

None of these are AI techniques. They’re management. The agent just made it expensive to be bad at them.


I gave this as the plenary session at Globe DevCon 2026. If your team is working through the same adoption questions, I’m happy to share what we learned — including the parts that didn’t work.

Working on the same thing?

If you're working on something similar, I'd like to hear about it.