Agentic Development is not about starting an agent. It is about building the scaffolding.
What Agentic Development actually means
Who does what
The agent works
- Read and understand code
- Propose changes
- Run tests
- Evidence the result
Every step stays provable on its own
The human decides
- Scope the task
- Approve the plan
- Approve the merge
- Answer for what ships
Both held together by the structure
The structure enforces
- Every task has a written plan
- Every plan runs in its own separate workspace
- Nothing merges that fails the quality gate
This is how several developers can run several agents at once without getting in each other's way — not because everyone is being careful, but because the structure rules it out.
The engine is not your competitive advantage
Five words from a tyre advert say what this is about. The engine was never the problem. What mattered was always how much of it reaches the road. In software development with AI, the engine is the same for everyone today. Your competitor uses the same model you do, at the same price, starting tomorrow morning. The difference only appears afterwards — in what is built around the model. Who is at the wheel does not change: you drive. We provide the grip — the scaffolding that turns engine power into a track you can hold at speed. Vibe coding means: prompt in, code out, eyeball it, move on. For a prototype on a Friday afternoon that is exactly right. For code that runs for three years, is maintained by someone else and in the worst case ends up in front of an auditor, it is not.«Power is nothing without control.»
Advertising claim by Pirelli, in use since 1994
Goal
Vibe coding: prototype, spike, throwaway demo
Agentic Development: code that goes to production and stays there
Context
Vibe coding: ad hoc in the chat, lives in one session
Agentic Development: specified: repo conventions, CLAUDE.md, skills
Verification
Vibe coding: eyeballing — «looks good»
Agentic Development: tests, types, CI, review gate before the merge
Repeatability
Vibe coding: not reproducible
Agentic Development: same process, same result, next month too
The human's role
Vibe coding: prompter
Agentic Development: architect and reviewer
Cost of mistakes
Vibe coding: paid later, by someone else
Agentic Development: surfaces early and cheaply
Audit
Vibe coding: no trace
Agentic Development: a history you can follow
Speed is only worth something if the result holds. A race car without grip is not fast — it is just loud. A development team without tests, without a specification and without a review gate does not produce faster. It only produces rework faster.
The scaffolding around the agent — four building blocks
The ordering «steer before, check after» follows Birgitta Böckeler's account of guides and sensors: Harness Engineering for Coding Agent Users
Guides · steer before
Skills · Documentation
Sensors · check after
Definition of Done · Evals
Guides · steer before
Skills
Reusable working instructions — the agent knows how we do things, instead of guessing anew on every task.
See our skills on GitHubDocumentation
Written so humans and agents both read it. What is written nowhere, an agent cannot take into account.
Sensors · check after
Definition of Done
When something is finished. Binding, not renegotiated per task — otherwise the day's mood decides.
Evals
Checking whether a judgement holds up — where a classic test asks the wrong question.
When checks run
Beside the agent
While it works, in seconds
Fast, unambiguous checks run along as the agent writes. It corrects itself before a human ever sees the code.
- Type checking and code rules on every change
- Fast tests for the parts that were touched
- Compliance with the agreed architectural boundaries
After integration
When the work comes together, in minutes
Whatever takes longer runs once the change is merged with the rest — at that point the wait no longer holds anyone up.
- The full test suite against fixed reference results
- A review pass on the bigger picture, not just the line
Continuously
Independent of individual changes
Some things decay slowly and show up in no single change: plan and code drift apart, documentation ages, structures move away from the design.
- Regular checks that plan, documentation and code still agree
- Pointers to drift that has accumulated over time
The order is the rule: what a machine can decide unambiguously is decided by a machine — fast, consistently, without discretion. AI comes in only where a judgment is needed that cannot be captured in rules.
No surprises
The agent builds the system. It is not part of it.
We do not let agents monitor and steer unsupervised. We use them to build and run the systems that do exactly that — automation, pipelines, metrics, dashboards, release engineering. What runs in production afterwards is deterministic: same input, same result. The agent built it; it does not make decisions inside it.
Less code, not more
Every line of code has bugs. An agent writes ten times faster — which is only a gain if there is not ten times as much code at the end. We do not measure how much was produced, but how little was needed.
Faster means more safety net, not less
When changes land faster, you need more metrics, more monitoring, faster review and deploy processes — to keep up, and to correct mistakes quickly. The agentic setup itself is an investment, so that it delivers predictable results. Doing the same thing faster is not enough; it has to get better.
Where the scaffolding reaches its limit
A ticket from our own platform project: roughly 600 lines across three layers, clean tests, green build, properly documented. Every check was green — and nobody wanted the result anyway. No sensor in the world answers whether what was built is what was meant.
That is why the work moves forward in the process. For us that means around four hours a day spent on markdown instead of code. If the plan is precise enough, the pull request holds no surprises — and the review effort collapses.
What changes in the craft when agents work alongside you
We build the prototype instead of the mockup
The idea used to take shape in Figma or Miro and was rebuilt afterwards. Today the interactive prototype is finished sooner than the picture of it — and you can use it instead of imagining it. Discussions about work in progress get shorter and more honest.
We do not chase 100 % test coverage
An agent writes tests almost for free, and that is exactly the trap: test everything and you test nothing properly — you end up with checks that only cost effort. The definition of done says what belongs under test. And where an agent judges rather than computes, line coverage measures the wrong thing anyway; that is what evals are for.
We lead agents instead of working through tasks
The work shifts from writing to scoping, reviewing and deciding. That is more demanding, not more comfortable — and it is why experience matters more, not less.
When the agent leads — and when the human does
Agent-led — the agent leads
- Similar changes across many files
- Catching up test coverage where it is missing
- A migration, step by step
- Exploring an unfamiliar codebase
- Building a prototype to settle a question
Human-led — the human leads
- When the requirement is still unclear
- When an architectural decision needs experience
- When a mistake would be expensive
- When it must be decided what «done» means
- And that is how it should stay
Two federal portals on one platform — and our own tool
Naturgefahren.ch
The natural hazards portal brings together hazard data from several sources and turns it into warnings for the web — accessible, certified to WCAG 2.1 AA.
Since the project started, every change goes through the agentic workflow.
During a storm everyone hits it at once — which is why the quality gate in front of it is not negotiable.
Open naturgefahren.chMeteoSwiss
Almost 100 weather products in real time, a dedicated mapping framework — for the Federal Office of Meteorology and Climatology.
Also since January 2026: no change outside the agentic workflow.
The automated quality gates in this application are no by-product — they are the scaffolding that makes exactly that possible.
What we built for MeteoSwissQuote generator
Our own product, in two stages: we pitch to clients with the prototype — five variants run publicly. If that turns into an engagement, it becomes the production application on the CDS platform, with access control and further generators.
Both stages run through the agentic workflow — the first prototype was up in March 2026, in a single morning.
The prototype from the pitch is the basis of the production application, not a throwaway beside it. This is where we started, on ourselves, before recommending it to clients.
See the quote generator
Who actually writes in a project like this
Almost half the contributions do not come from engineering
Sales, finance and product ownership write along — not as reviewers on the side, but as authors in the log. Whoever knows the requirements can bring them in without translating them first.
The approvals are in the log, by name
Wherever a human decided, there is an entry with their name on it: plan approved, merge approved. Those entries carry no agent signature — they are the points where someone took responsibility.
One agent is a team member with its own account
In our own company repository, Qubert contributes under its own address — our first autonomously contributing agent. You can see in the history who wrote what, because it does not commit under someone else's name.
That is the point: not that agents type faster, but that a team gets wider. Whoever knows the domain gets closer to the result.
Let's talk about your next step
In the AI Potential Analysis we look together at where agentic development holds for you — and where, deliberately, it does not.
Rather talk in person?
Max — Give us a call or send an email — whichever you prefer.