Skip to content
ITWillRock

Method

How we work: one method from discovery to operation.

Any engagement decomposes into discovery and development. The quality of discovery decides the quality of everything after it. We name the two stages most vendors skip: launch and operate. AI moves work inside every stage and removes no gate. We call the whole thing Solid Ground: four stages, each ending at a gate you sign.

01The method

Solid Ground: four stages, four gates.

The Solid Ground method: four stages, four gatesFour layers stacked like a geological section, labeled Discover, Build, Launch, and Operate. A star between each pair of layers marks a gate where a person decides. A dashed line links the gates.01 Discover02 Build03 Launch04 Operategate: roadmap signedgate: release acceptedgate: go-live approvedgate: quarterly review
Four stages. At each gate you decide: continue, change direction, or stop.
01

Discover

Know what to build and why

2 to 4 weeks (Assessment: 2; Discovery Sprint: 3)

Activities
  • Interviews
  • Current-state mapping
  • AHP-based prioritization workshop
  • Architecture options
  • Risk and compliance review
  • Estimate
Deliverables
  • Roadmap
  • Solution architecture
  • Prioritized backlog
  • Optional proof of concept
Gate (signed by you)
Roadmap and architecture accepted; go or no-go on build
02

Build

Working increments you can use

From 8 weeks

Activities
  • Two-week sprints
  • Agent-assisted implementation inside the pipeline described below
  • Code review
  • Automated tests
  • Security review
  • Architecture decision records
Deliverables
  • Working software every two weeks
  • Test reports
  • ADRs
  • Agent evaluation results
Gate (signed by you)
Release candidate accepted
03

Launch

Production without surprises

2 to 4 weeks

Activities
  • Environments as code
  • Migration rehearsal
  • Validation documentation where required
  • Runbooks
  • Training
Deliverables
  • Production release
  • Runbooks
  • Rollback plan
  • Handover pack
Gate (signed by you)
Go-live approved; stable for 30 days
04

Operate

Keep it working and improving

Monthly; exit with full handover at any time

Activities
  • Monitoring
  • Incident response
  • Updates
  • Cost review
  • Quarterly roadmap check
Deliverables
  • Monthly report on availability, incidents, cost, and change
Gate (signed by you)
Quarterly review: continue, change, or hand over

An exit package (code, infrastructure as code, runbooks, decision records) is ready at every gate, not only at the end.

02Principles

Principles

  1. 01

    Automation, integration, and common sense

    Most problems are solved by connecting what you already have and removing manual steps. New technology, including a model, comes after that.

  2. 02

    Roadmap first, then agile, because requirements are never final

    A roadmap and a high-level architecture keep the direction steady while sprints stay reactive. We plan for change instead of pretending it will not come.

  3. 03

    Put first things first

    We use structured prioritization (AHP) to separate the important from the merely urgent, and we tell you what the team is working on and why, every week.

  4. 04

    Discovery before development

    The quality of discovery artifacts sets the ceiling for everything built after them.

  5. 05

    Know where AI stops

    A model does not know when it is wrong; the system around it has to. We write down what AI will not do and why. A rule beats a model when a rule will do, a person signs anything with consequences, and "no model" is a valid recommendation.

  6. 06

    Small senior team, no agency overhead

    You can buy the same result from a large vendor and pay for the layers between you and the people who write the code. We do not have those layers.

03Agentic engineering practice

Agents do the work. Engineers own it.

Our own pipeline, and the one we install in client teams, in enough detail to be checked.

Our own pipeline

  • Roles: one agent, one role, a bounded tool set. A research agent reads the repository and the ticket and drafts a plan; an implementation agent works on one task in a branch (no deploy); a test agent writes and runs tests; a review agent drafts comments against the plan, the coding standard, and the security checklist.
  • Gates: an engineer approves the plan before code is written, reviews every diff and test run, and decides what stands; no agent merges. Authentication, payments, data migration, and validation evidence need a second reviewer.
  • Evaluation: build, tests, static analysis, and dependency checks must pass; for AI features the evaluation suite runs in CI and blocks the release on regression. Reviewer acceptance rate is tracked per agent and task type; an agent whose acceptance drops is pulled until the cause is fixed.
  • Traces: prompt, model and version, diff, test run, approver, timestamp, kept for the life of the project.
  • Metrics: cycle time from commit to production, review lead time, defect escape rate, and model spend per change, reported per increment.

What agents do

  • Research the codebase and documentation
  • Draft plans
  • Implement changes
  • Write and run tests
  • Draft review comments

What people do

  • Set the plan
  • Review every diff
  • Decide what merges
  • Own the architecture
  • Own the evaluation set
  • Talk to you

What agents never do

  • Merge to the main branch
  • Touch production data
  • Approve validation evidence
  • Change the evaluation set that judges them
  • Communicate with your customers unsupervised

What you get

  • A trace for every change (prompt, model version, diff, test run, approver, timestamp)
  • A written AI-use policy for your project
  • Your code and data stay in your tenancy
  • Model provider and region written into the contract
  • Cycle time and defect rate tracked per increment and shared with you
  • Tooling in use: coding agents in the IDE and in CI, an evaluation harness that runs in CI, and a model gateway; providers and model versions are named in each contract
The agentic engineering loopFour nodes in a loop: Research, Plan, Implement, Review. Review connects to a star labeled Human sign-off, which returns to Plan for rework or continues, through a dashed edge, to Merge and deploy. Below the loop a trace row lists prompt, model, diff, test run, approver, and timestamp.ResearchPlanImplementReviewMerge and deployHuman sign-offreworktrace: prompt · model · difftest run · approver · timestamp
The red star is the human. Nothing merges or deploys without a named person.

This is not a manifesto. It is the process we learned building software that regulators read, and the one we install for clients.

04Engagement models

Engagement models

  • Architecture and AI Readiness Assessment

    Use it when
    You need a decision in two weeks, including on AI
    Billing
    Fixed price

  • Discovery Sprint

    Use it when
    You are scoping a build
    Billing
    Fixed price

  • Agent Pilot

    Use it when
    You want one workflow automated and measured before committing
    Billing
    Fixed price

  • AI Pipeline Pilot

    Use it when
    You want coding agents in one team's delivery, with gates, evaluation, and before-and-after numbers
    Billing
    Fixed price

  • Dedicated product team

    Use it when
    Build and operate over months
    Billing
    Monthly, team-based; stop at any increment with 30 days' notice

  • Time and materials

    Use it when
    Changing scope, short work
    Billing
    Hourly or daily

  • Fractional architect

    Use it when
    Ongoing oversight without a hire
    Billing
    Monthly retainer, 2 to 5 days a month

  • Operate retainer

    Use it when
    Running what we built
    Billing
    Monthly, with agreed response times

Cost drivers: scope clarity, compliance load, number of integrations, data migration, operate hours, model spend during build and in operation. Not cost drivers: our office, a sales layer, or a padded discovery phase. We quote ranges after discovery and fixed prices for fixed scopes. Model usage is quoted separately and capped in the contract.

05Questions

Questions

See it applied to your problem.

Bring one problem. We will tell you which entry point fits and what it costs.

Start with discovery

For sure.