Make AI speed up delivery, not just typing

In a three-month pilot I build an AI SDLC with one of your teams. Agents are wired into how work is specified, written, reviewed and shipped. We measure what changed in speed and quality, and prepare the process for the rest of your teams.

Discuss a pilot

How the pilot works

AI writes code faster. Delivery barely moves.

Your engineers already use Cursor, Claude Code or Codex and close individual tickets quicker. The team as a whole ships at almost the same pace.

Every engineer has their own AI setup

Prompts, tools and tricks live in personal configs. What works for one person never reaches the next team.

The bottleneck moves downstream

Code appears faster, so specs, review, testing, rework, approvals and release take a bigger share of every ticket.

Agents work blind

Requirements sit in Jira, decisions in Confluence and in people's heads, conventions in old review threads. An agent sees none of it.

Nobody can say whether it worked

More pull requests, more lines. But is lead time shorter? Are there fewer rollbacks, less rework? Without a baseline nobody knows.

Faster typing is not enough. The whole path of a task has to be rebuilt, from requirement to production.

Four levels of AI adoption. Most teams are on the first.

Everyone starts with personal tools, and most teams get stuck on the next step. Moving from level one to level three changes how work is specified and accepted. A stronger model will not do that for you.

  1. Level 1 · AI assistant

    AI helps the engineer

    Autocomplete, chat, one-off scripts and tests in Cursor or Claude Code. One person gets faster.

    Faster engineer

  2. Level 2 · Agentic coding

    The engineer directs agents

    An agent gets a task with context and makes most of the change. The engineer frames the task and accepts the result, writing far less code by hand.

    The agent writes the code

  3. Level 3 · AI SDLC

    Agents across the whole cycle

    Specs, specialised agents and quality gates join into one process from requirement to production. People check work at defined checkpoints. The whole path to release gets faster.

    Faster teamPilot goal

  4. Level 4 · AI-native organisation

    One process for all of engineering

    Teams share knowledge, rules, agents, gates and metrics. A new team starts on a working process from day one.

    Shared engineering base

The diagnostic shows where you are and which step pays off this year. Skipping a level does not work.

The harness: where your team and agents work together

The spec becomes the main artifact of a task. Agents write code from it; people set boundaries and accept the result. One agent's work is checked by another. If a check fails three times in a row, a person takes over.

Quality gatesci / review
Specsspecs
Knowledge basedocs / adr
Rules and boundariesagent rules
Your repositorygit
Four layers on top of your codebase
Quality gates
Routine changes are checked automatically. Where a mistake is expensive, a person reviews the code.
Specs
Acceptance criteria are bound to tests, so the agent does not invent requirements.
Knowledge base
Architecture map, contracts and decision log, versioned in git next to the code.
Rules and boundaries
Agent instructions for your stack and codebase. Linter and CI configs are protected paths that agents cannot change.

Five steps: from diagnostic to handing the process to your team

  1. Diagnostic

    I map how your delivery actually works. Repositories, architecture, and where tasks are defined — in a Jira you cannot drop, or in markdown specs in the repository.

    We record baseline metrics, so in three months the result is a number, not an impression.

    2 weeks

  2. First version of the harness

    Rules, knowledge base, specs and quality gates for your stack.

    The harness itself takes days. The rest is agreeing on roles — who owns it after the pilot.

    2 weeks

  3. Launch

    The pilot team runs two or three real tasks from its backlog through the full cycle — spec, agent code, review, release. After the workshop the team works only the new way.

    Defect KPIs are paused during the pilot, so people are not afraid to try.

    Workshop

  4. Support

    I am in your team chat. Git shows where the agent worked and where a person fixed code by hand. Every such fix is analysed and turned into a harness rule.

    A hand fix brings the same mistake back in the next task. Fix the rule or the check that let it through.

    2–3 months

  5. Results and handover

    We compare DORA and AI metrics with the baseline — how many decisions agents make and how that affects quality.

    One to three of your engineers learn from day one as the internal harness team. They launch the next team themselves.

    Review

What stays with you

Everything lives in your repository as part of the codebase and keeps working after the pilot.

  • Knowledge base and architecture map
  • Decision log (ADRs) as a team habit
  • Prompt templates for recurring tasks
  • AI-assisted code review policy
  • Quality gate checklist per task type
  • Internal harness team: 1–3 people

What a mature process looks like

Two systems I built and run myself. Both work in production, and every mechanism below exists in code.

Briefly: a newsroom without a human editor

Own product · multilingual publishing

Briefly publishes digests on AI, software and security in English, Spanish, Russian and Portuguese. No person approves a post. A Writer agent drafts, a Reviewer agent checks every item against its sources, and Dagu runs each step as an idempotent job.

  1. Sources
  2. Writer
  3. Reviewer
  4. 4 languages
  5. Publish
blocking findings go back to the Writer — at most three rewrites, then the step fails

Retries live outside the service

The service never retries on its own. Dagu re-runs a failed step, which is safe because every step is idempotent.

Decisions are in git

Every architectural decision is an ADR in the repository. People and agents read the same reasons.

How a mistake became a rule

  1. Symptom. One Portuguese edition took 15 Writer/Reviewer cycles across four runs.
  2. Data, not a guess. The review log showed the Reviewer rejecting ordinary loanwords like “offline” and “hub”, next to one real error — a professor turned into a researcher.
  3. Cause. Any style remark blocked publication, and a full rewrite fixed one complaint while breaking another item.
  4. Rule in the harness. Findings are now typed blocking or advisory. Only factual and fidelity errors block, and code, not the model, decides approval.
  5. Every next edition. The rule is an ADR and a response schema, so every later edition runs under it.

The fix went into the harness, not into one article.

Factory: GitHub issues in, reviewed pull requests out

Own tool · software factory

A self-hosted agent factory on Dagu. I file a goal as an issue; a planner agent splits it into tasks, a coder agent opens a pull request per task, and separate agents review, test and judge it. GitHub is the only source of truth for state. The factory also develops itself.

  1. Planner
  2. Owner check
  3. Coder
  4. Review · QA · Judge
  5. Owner check
findings go back to the coder as a rework round

The author never checks its own work

Review, QA and the merge gate are separate roles. Verdicts are bound to the pull request's head commit, and gates are checked by code, not by an agent's claim.

Agents cannot loosen the rules

Linter and CI configs are protected paths. Any agent edit to them is reverted before the push.

How a mistake becomes a lesson

  1. Symptom. Four pull requests in a row failed QA, although the project check passed.
  2. Cause. The planner wrote validation commands with shell syntax that breaks under sh -c.
  3. Lesson. A retro agent recorded it in docs/lessons.md with evidence — the rule, the pull requests, and what to watch for.
  4. Next goal. The planner reads the lessons before it plans, so the mistake does not come back.

Lessons have a lifecycle: open, applied, verified — or reopened with new evidence.

Five principles

Your team builds the harness

There is no box to install. Your engineers build the agents and rules with me, for their stack and codebase. What a team built itself, it maintains.

Everything stays with you

Knowledge base, decision log, prompt templates and policies live in your repository and keep working after the pilot.

Checks scale with the blast radius

A change inside one module passes automated gates. A change that touches other teams goes to architecture review.

Engineers edit instructions, not output

The main shift for an engineer — they edit agent instructions, and code follows from them. Patching agent code by hand is like patching a binary after the compiler.

One path, fail fast

No silent fallbacks and no hidden retries. When something breaks, it stops with a diagnosis and a person decides what happens next.

What I don't promise

  • Fully autonomous agents in one quarter. The pilot's goal is a stable process in one team and people who carry it to other teams.
  • Architecture and team-structure decisions stay with you. I bring the process and the numbers for them.

Who you work with

Michael Kozii

Engineering practice, harness design, agent systems

Backend engineer with twelve years in commercial software, based in the European Union. Senior Backend Engineer at a large product company, working in Go, since 2022. Before that, five and a half years at Spryker as Senior Backend Engineer and then Technical Lead — e-commerce modules, Docker infrastructure, ERP, CRM, PIM and payment integrations, and consulting customers on Spryker infrastructure. Earlier, ad tech at Lucky Labs, an RTB network serving a billion impressions a month. Builds and runs AI agent systems in production, including Briefly and Factory.

Let's start with a conversation about your team

On the first call we look at how tasks are specified and built today, where AI is already used, and what can be measured. After the call it is clear which harness to build and which team to start with.

Write to me [email protected]