Mickel Tech.
ENDE
Book a call
01 / Agentic SDLC

From requirements to autonomous delivery.

Most engineering orgs run yesterday's methodology against agents that already outpace them, and most rollouts only train developers, the one stage that no longer holds the work back. Agentic SDLC fixes both.

Book a 30-minute discovery call
Strategy session
from CHF 3k
Diagnostic
CHF 15-25k
Code factory
from CHF 40k
R&D operating model
from CHF 50k
Legacy migration
from CHF 60k
Group rollout
from CHF 30k / entity
02 / Why the whole lifecycle

The bottleneck moved. Most AI tooling rollouts pretend it didn't.

When agents write production code in minutes, typing speed stops being the constraint. The pressure moves up: to product framing, requirements engineering, spec quality, review capacity, QA. Tooling that only targets the coding layer optimises the part of the pipeline that no longer holds the work back. Agentic SDLC covers the whole lifecycle instead, from requirements through review, QA and deployment.

What makes this differentDevelopers → the whole R&D org

Most programs coach developers and stop. But if coding is no longer the constraint, training only coders just pushes the queue downstream to review and QA. We onboard the whole pipeline, ideation, requirements engineering, build, review and QA/QE, so the entire R&D org moves together. That is why engagements are scoped by R&D head-count, not developer seats.

What changes when you treat the whole product cycle
  • Specs are the promptsRequirements engineering becomes the highest-leverage activity. Specs are the prompts. Bad specs produce bad agents. Good specs compound across every loop downstream.
  • Review carries correctnessAgents write the first draft. People and other agents review. Eval gates and cross-model review carry correctness, safety and style before anything ships.
  • The unit of work is a contextThe unit of work is a connected context: product docs, repo, design system, observability. Not a Jira card. Prompts, evals, guardrails and agent skills all live in version control.
  • Production feeds the specNo more isolated demos that never leave the slide deck. Production observability feeds product feedback. Product feedback sharpens the spec. The system gets better while it runs.
03 / Where AI-first delivery breaks

Four patterns that stall AI-tooling rollouts at L1.

These are not tooling problems. They explain why a Cursor or Claude Code rollout caps out at 10-15% individual lift instead of becoming the org-wide shift the business case promised. You will recognise at least two.

  • 01

    Production cheaper, maintenance not

    An agent can produce in a week what used to be six months of work. The team that has to review, understand and own that work cannot scale at the same rate. Output without back-pressure becomes the most expensive cleanup the next quarter inherits.

    This is what the methodology shift is built around.

  • 02

    Sprint apparatus does not survive

    When an agent ships in four hours, the dailies, refinements and retros that used to finish loose specs over two weeks have nothing to attach to. The mechanism that compensated for vague requirements is gone. The calendar is still full of meetings designed for it. Specs have to land precise upstream, or the work degrades.

    Building the new loop is what the L1 → L2 sprint exists for.

  • 03

    Agent-readiness is codebase health

    A messy codebase was already expensive for humans. Agents scale that mess faster. When an agent cannot run the right command and verify the result, it still produces confident-looking output that breaks at second review.

    Boring fundamentals and the agentic layer go in together. Or neither pays off.

  • 04

    Adoption is cultural, not just tooling

    Senior engineers already have a working system. Decomposing tasks for an agent, providing context, deciding when to take over: the early months feel like training wheels before they feel like leverage. Mandates produce quiet refusal.

    Coaching is the engagement, not an add-on.

04 / Maturity model

Five levels, L0 to L4. Most orgs sit between L0 and L1.

The ranges are org-level: they measure what a whole organisation ships once specs, review and release are rebuilt around agents, at constant or better DORA change-failure rate. Careful per-engineer measurements come in well below them. L4 is rare.

  1. L0

    Pre-AI

    No AI in delivery

    Baseline
  2. L1

    Assisted

    Copilots, manual usage

    10-15% individual
  3. L2

    Foundation

    Tooling + methodology rolled out

    20-30% in 90 days
  4. L3

    Spec-driven

    Eval-gated agentic delivery

    2-3× sustained
  5. L4Rare

    Autonomous

    Agents ship, humans set priorities

    Up to 5-10×, rare
05 / How to engage

Start small, build in modules, scale across the group.

Fixed-fee and instalment-friendly. Start with a session or a diagnostic, take the programme modules in the order your codebases need, then roll the setup across the group.

Way in
1 day

Strategy Session

from CHF 3k

One question, one day, a written recommendation. Creditable against any follow-on within 90 days.

Scope and deliverables

A focused full day, on-site or remote, on one specific question: where to start with agentic SDLC, vendor selection, architecture review, "should we even build this." You leave with written notes and a clear next-step recommendation by end of day.

Outcome

A defensible answer to your actual question, not a generic deck. The cheapest way to test whether we work well together, and the fee is fully creditable against any follow-on engagement within 90 days.

Deliverables
  • Working session with the right people in the room
  • Written notes plus a clear next-step recommendation
  • Optional 30-min follow-up call within two weeks
Best for

Anyone who wants to test the fit before committing, or get an outside read on a specific decision.

2 weeks

SDLC Diagnostic

CHF 15-25k

L0-L4 maturity scoring across five pillars, prioritised opportunities, a 90-day roadmap and a board-ready readout.

Scope and deliverables

Two weeks. L0-L4 maturity scoring across five pillars (product, spec, code, review, ops). Process map, prioritised opportunities, 90-day roadmap, and a board- or owner-ready report.

Outcome

A defensible diagnosis. You leave with a quantified baseline and a sequenced plan that survives an owner or board review, and it pays for itself the first time it stops you funding a low-impact pilot.

Deliverables
  • Maturity scorecard (L0-L4 across five pillars)
  • Top five opportunities with effort and impact
  • 90-day rollout plan with KPIs
  • Executive readout
Best for

CTOs, VP Engineering and owners who want to know where their R&D org really stands before investing.

Agentic SDLC Programme

Three modules · scoped by R&D head-count

Three modules, each with its own fee. Modern codebases take the factory and the operating model. The legacy core takes the migration module, measured on whether behaviour survived and what the rest will cost.

One team

Code Factory Build

from CHF 40k

The factory, built with one lead team across its whole pipeline, product to QA/QE. Your team owns it.

Scope and deliverables

We build your agentic factory with one lead team and onboard its whole pipeline, from requirements engineering through build, review and QA/QE. Tooling, eval gates, cross-model review, methodology training, lighthouse lanes co-shipped, KPI baseline locked. Train-the-trainer throughout: your team owns it, we do not.

Outcome

A working factory your team runs without us, and a measurable cycle-time and review-time uplift inside the first 90 days. Priced in head-count bands, fixed and instalment-friendly, never open-ended.

Deliverables
  • Standard tooling deployed (model selection, license + prompt management)
  • Eval gates and cross-model review (Flow-Next / MergeFoundry pattern)
  • Whole-pipeline onboarding: product and spec, build, review, QA/QE
  • Lighthouse lanes co-shipped end-to-end
  • Cycle-time and review-time baseline locked
  • Methodology playbook your team owns
Best for

Software-led SMEs that want one team running the factory end to end, product through QA/QE, before the rest of the org follows.

For software SMEs
Whole org

R&D Operating Model

from CHF 50k, by head-count

Readiness levels per codebase, pods of three to five, a central team with a lab, converted roles.

Scope and deliverables

We redesign the R&D org around agents. Each codebase gets its delivery setup first and climbs four readiness levels; teams commit to throughput at level 3. Pods of three to five, a small central team with a lab inside, existing roles converted to new ones, Kanban capped by review capacity.

Outcome

An org where every codebase has a known readiness level, every pod has a named reviewer, and every improvement the lab finds reaches all pods. Measured per team, against a baseline locked before the change.

Deliverables
  • Readiness level per codebase, with the plan to level 3
  • Pod design: spec lead, builders, named review lead
  • Central platform team and lab, staffed from your people
  • Role conversion plan, juniors protected
  • Flow rules and team-level metrics with a locked baseline
Best for

R&D leaders with about 15 to about 500 engineers, often on a mix of modern and legacy code, who want the org shape to change along with the tools.

R&D operating model
Legacy core · own measure and fee

Legacy Migration

from CHF 60k (scoping CHF 15-25k)

One bounded context moved and checked against the old system, plus a costed estimate for the rest.

Scope and deliverables

A module with its own measure and its own fee. Typically about a third of one of your teams for about three months; scoping sizes the context and the duration for you. Together we move one more bounded context of the old system onto the new architecture and measure what it took. That measured run becomes a costed estimate for the rest of the system.

Outcome

Two things a board can act on: one context migrated, with its behaviour checked against the old system, and an estimate for the remainder built from what actually happened. If the work stalls, you still keep far better documentation of the old system than you started with.

Deliverables
  • A documentation layer generated from the code, with the gaps closed in interviews
  • One more bounded context rebuilt on the target architecture
  • Behaviour checked against the old system, using the strongest check available
  • A costed estimate for the rest of the system, built from the measured run
  • Guaranteed minimum: much better documentation of the old system
Best for

Software companies whose core system is decades old, where the knowledge sits with a few long-serving people and every rewrite estimate came back as "multi-year".

Legacy migration
Then scale
per entity

Group Rollout

from CHF 30k / entity

The proven factory, templated one entity at a time. Per-entity cost and time keep dropping.

Scope and deliverables

Once the factory is proven in one team or company, we template it across the group, one entity at a time. Each rollout reuses the proven playbook, so per-entity cost and time keep dropping while standards stay consistent across the portfolio.

Outcome

One proven factory becomes the group standard: the same methodology, tooling and KPIs across every team and company, without rebuilding from scratch each time.

Deliverables
  • Templated rollout per entity (reuses the proven playbook)
  • Shared standards: tooling, evals, guardrails, KPIs
  • Local champions trained in each entity
  • Group-level KPI view across entities
  • Program coordination across the portfolio
Best for

Group and holding CTOs standardising agentic delivery across multiple teams or companies.

All prices in CHF, excluding VAT.Factory Care (optional): a light retainer from CHF 2k / month that keeps your factory on the frontier as models and tools shift. Opt-in, never a lock-in, and your team still owns the system.
06 / Tools

Fluent in the standard stack. I also build my own.

Most engagements run on whatever your team already uses (IDEs, model providers, CI, observability). Where I have hit a real ceiling in that stack, I have built tools of my own to push past it. They inform the methodology I bring; they are not a precondition for working together.

Agentic SDLC200%+Cycle-time uplift · 250+ engineers · 3 workshopsSwiss software company · 250+ engineers across multiple dev organisationsAgentic SDLCUp to 500%Delivery speedup · 3 new products shippedUK software company · custom agentic coding pipeline · highly competitive market
Free guide · 16 pagesSDLC Maturity ModelWhere your engineering organisation sits today, and what each level looks like.For: CTOs, VP Engineering, PE operating partnersDownload the PDF
07 / Frequently asked

What engineering leaders ask first.

Is this just about generating code faster?

No. The work covers the whole development lifecycle, not just code generation: product framing, requirements and specs, review, QA, documentation and deployment. Once agents write production code in minutes, the constraint sits in those stages, which is why a rollout that only speeds up typing hits its ceiling inside a quarter.

Is this just selling Cursor / Claude Code / OpenAI Codex rollouts?

No. Tool choice, adoption and engineer coaching are part of the work, but a small part. The methodology shift, eval gates, cross-model review, everything-as-code, observability flywheels and organisational redesign are where the work sits and where the value is. The tools change every quarter; the methodology does not.

Where do Flow-Next and MergeFoundry fit?

Flow-Next is the open-source pattern that any team can adopt independently. MergeFoundry is the commercial platform I am building separately under MergeFoundry, Inc, relevant when a portfolio wants the L3/L4 patterns deployed once and reused everywhere. Neither is required to engage me; both are available if useful.

How do you measure success?

Cycle time, review time, deploy frequency, change failure rate (DORA core), plus SDLC-specific metrics: spec quality scores, eval-gate pass rate, agent-vs-human authorship ratio, observability-to-spec feedback latency. Baselined in week one of any engagement.

What about regulated industries?

Most of my work is in regulated environments: healthcare, finance, public sector. Eval gates, audit trails, deterministic pipelines and provenance are not afterthoughts; they are the architecture. I have shipped production AI inside a clinical CIS and inside legal-grade contract platforms.

Can this work on a legacy codebase?

Yes, and it runs as its own engagement. Legacy Migration is a separate module of the programme with its own measure and its own fee: did the behaviour survive, and what will the rest cost. A fixed-fee scoping phase sizes the work; then we rebuild one bounded context on the target architecture, check it against the old system, and turn that measured run into a costed estimate for the remainder. Agents carry most of the comprehension work, while executable checks of the old behaviour and human sign-off keep the result correct. The guaranteed minimum is far better documentation of the old system. The legacy modernisation page sets out the steps and both cut-over routes.

Will my engineers lose their jobs?

No, but their work changes. Specs, reviews, judgement on edge cases, product framing, agent supervision: these become the high-leverage work. Engineers who lean into that gain. Engineers who only type code lose ground regardless of whether you engage me. Better to do this on your terms.

Do you do remote-only or onsite?

Both. Most engagements are hybrid: 1-2 onsite days at start and at major milestones, remote in between. Pure remote works when there is a strong technical lead on your side. Pure onsite is rarely worth the price.

Where does this fit alongside my existing platform team?

Cleanly. The platform team owns the runtime; I own the methodology and the agent layer. We co-build the foundation and then your platform team owns it. I do not stay forever; that is the test of whether the engagement worked.

08 / Go deeper

Depending on where you sit.

Engage

Start with one call, then a diagnostic or a scoping.

We go through where your R&D org stands, which codebases are ready, and whether the programme or a single module is the right first step.

Book a 30-minute discovery callor write to gordon@mickel.tech