Context
This is the day-to-day development process I run at Cefalo on the Norwegian National Archive (Asta) work — a process I built and drive myself. It's built on Claude Code with a Jira MCP integration, and every stage of the pipeline is a separate custom skill that I built rather than a single monolithic prompt.
What started as my own personal workflow has since become the team's: the rest of the team is adopting the same pipeline for their own ticket work.
Problem & constraints
The goal was to raise delivery velocity without lowering the quality bar — this is a production government system, and speed can't come at the cost of correctness or safety.
That put hard constraints on how much autonomy the agent could be given. It must never operate outside a set of guardrails: no access to secrets, no pushes to develop, release, or master — those are blocked outright — and the agent is only ever allowed to work on feature branches. On top of that, I review every single change the AI makes before anything merges. Nothing lands without a human in the loop.
Options considered
Chat/autocomplete-style AI assist
Rejected
Using AI the way most people start out — as a chat assistant or inline autocomplete — speeds up typing, but leaves the analysis, design spec, planning, and review stages entirely manual. It underuses what the tooling can actually do end to end.
Full autonomy, no human gate
Rejected
Letting the agent run the whole pipeline and merge on its own would maximize speed, but edge cases get missed. A production government system can't absorb that risk, so removing the human checkpoint was never on the table.
Almost-autonomous pipeline with a human in the loop
Chosen
The agent runs the full pipeline — analysis through implementation and review — but I no longer write code by hand. I direct the architecture and review every change instead of typing it, with a human gate before anything merges.
Decision & architecture
The pipeline has seven stages, each implemented as its own custom skill run through Claude Code:
- Fetch the Jira ticket — via the Jira MCP integration.
- Analyze the requirement — turn the ticket into a concrete understanding of what's being asked.
- Generate a design spec — published to Confluence automatically, one page per ticket per sprint.
- Create an implementation plan — also published to Confluence, with progress commented back onto the Jira ticket via a dedicated skill.
- Implement — all work happens on a feature branch; the agent cannot push to
develop,release, ormaster. For UI work, designs come into the pipeline through the Figma MCP, so what ships matches the Figma design precisely. - Code review — run as a skill before anything is presented for merge.
- Security review — a second, separate review pass focused on security.
The human gate sits on top of all of it: I go through every change the AI makes, and nothing merges without that review. The documentation loop is automatic rather than a manual chore — design and plan documents land in Confluence and status updates land as Jira comments, per ticket, per sprint, without me writing them by hand.
Outcome
Development time has come down, and the pipeline finds more complex bugs than the previous manual process did — it resolves more cases than before.
The honest trade-off is that the bottleneck moved rather than disappeared: review now takes up more of my time than writing code used to. The pipeline also isn't perfect — it sometimes misses edge cases, and those get caught in my review rather than before it. The mitigation that's worked is investing more in the plan stage: a more thorough, "perfect" plan measurably reduces how often edge cases get missed later on. The rest of the team is converging on this same process as a result.