The common view
AI helps people write code faster, inside today’s workflow.
Each engineer uses it their own way, so the gains stay with whoever found them.
Services
AI SDLC
One flow from the spec to merged code, fitted to how far your teams have already gone with AI.
How we see the problem
Coding is one of seven stages.
A coding assistant writes code faster, and the queue moves to the spec before the code and the review after it.
- 01Planning
- 02Design
- 03Specs
Before the codeAre we solving the right problem, and is the product thinking complete?
- 04Coding
Where a coding assistant stopsFaster, one engineer at a time.
- 05Pull request
- 06Bugs and QA
- 07Release
After the codeReview, risk and QA, where the extra code now waits.
What we build toward
Spec-driven development, end to end: research, plan, implement.
Shared context, skills and standards carry the work from planning to release, so agents can take part in every stage.
Software factory
One place the agents run.
Build your software factory
There are many ways to define a software factory. Ours is a system of agents, centralized in one place, that builds software. Custom setups on each machine become a single definition in code that runs in the cloud. The same way engineers agree on CI, a team should agree on how its agents run.
The main reason
Agent efficiency, as a teamSkills and config live in that one definition, so the team improves its agents together, instead of copying config onto every machine and managing skill sprawl person by person.
Security
Managed in one placeWho can run an agent, and with which credentials and tools, is set once.
Return
Tracked for the systemSpend and outcomes are visible for the whole system, not pieced together from each machine.
What we build
One flow, from idea to merged code.
Every project moves through the same stages, and each stage runs as a skill your team can read, review and tune. Upstream, agents press for options and completeness. Downstream, they implement, review and verify.
Are we choosing the right problem?
Quality- Idea
The problem, why it matters and what to optimize for
- Brainstorm
Solution options and a recommended path
- Low-fi prototype
Prototypes of the best options
Is our product thinking complete?
Quality- Project plan
The customer problem and the chosen solution
- Hi-fi design
Optional
Technical overviewOptional, for complex projects
Execution
Velocity- Milestones
Work cut into releasable chunks
- Issues
A technical plan for each milestone, then issues an agent can pick up
- Implement
Test-first, to rules kept in the repo
- Review
An agent reviews until every comment is resolved
- QA
An agent runs the build, then a person checks it
- Predictable delivery
Work moves through the same stages every time, so delivery is easier to forecast.
- A way to improve
Each stage is a skill the team reviews and tunes as it learns what works.
- Where the hours go
Agents move the code. The team’s hours go into the spec and the review.
Compounding
Each run leaves the factory better.
The flow moves one project through. What compounds is what the factory keeps: a skill tightened, a drift caught, a rule the next team inherits.
Continuous improvement
The factory keeps the lessonA review comment that keeps coming back becomes a check in the skill. A stage that wastes a cycle gets rewritten, and the next project starts from that.
Autonomous monitoring
Agents notice the driftThey watch the pipeline, the previews and production. When a build, a metric or a run goes off, they open the work.
The closed loop
A miss comes back to the skillA rejected pull request, a bug or a customer report returns to the stage that let it through. The same miss gets harder to repeat.
Every team
One improvement, the next runA tighter skill or rule lives in the single definition the agents run from. The next run on any team picks it up.
Beyond the flow
Five harder problems the flow depends on.
Once the flow runs, the next gains come from the pieces around it. These are the ones we build most often, in the repositories, pipelines and tools your teams already use.
- Start here
- Writing clearly
- Visual basics
- Shared controls
- Page and panel layouts
- Task flows
- Examples with evidence
ComponentIn the repo
Button
variantprimarylinesizesmallmediumuseOne primary action per view
Layout rule
A selected item opens in a side panel. A task with steps gets its own page.
Principle
Clear beats brief: name the action, not the control.
Agents read the same guidance toPrototypeBuildReview screens
Issue 214Ready for agent
Add a CSV export to the invoices page
- Picked up by a cloud agentStarted from a comment on the issue
- Read the plan and the repo’s rulesMilestone plan, acceptance criteria and team rules
- Wrote the tests, then the change6 tests added, all passing
- Opened pull request 482Preview environment and review start
Ran in the cloud, away from any developer machineThe issueA PR commentThe pipeline
Preview for pull request 482Clean build
Set fresh on every run
- Saved state clearedEarlier runs and totals
- Logins and IDs createdNo setup by hand
- Feature flags set for this runinvoice-export on
- VPN access and SDK versionsPinned
Browser tests, run by the agent
- Sign in as a finance userPass
- Export March invoices to CSVPass
- Totals in the file match the pagePass
Results posted to the pull request, ready for human QA
Pull request 4822 of 3 comments resolved
41
42
43−
44+
45+
46
47+
48
Re-review
Runs again on every push until each comment is resolved. A second model checks each finding before it is posted.
Risk check for pull request 482Low risk
- Under 500 lines212 lines
- Has tests7 added
- No API contract changes
- No database migrations
- Front end behind a feature flaginvoice-export
- No core components or global CSS
Approved by the service accountLow risk moves straight on
Everything elseA person reviews it
Judgment calls stay with people: event contracts, high-risk queries and performance.
What it runs on
Seven surface areas, built over time.
At any stage, the software factory runs on the same seven foundations. Each one has to be built. A team that skips one finds out in the first agent run, and each one gets deeper as the work grows.
- 01
Context and skills
Shared knowledge, conventions and skills kept in the repo, so every agent and engineer works from the same playbook.
- 02
Async agent invocation
A durable place to start and manage agents outside a live chat.
- 03
Reporting and KPIs
What agents do, how often they do it, and whether outcomes improve.
- 04
Design system
Consistent components and interaction patterns, so what agents build fits across products.
- 05
CI/CD actions
Hooks that let agents take part in the delivery pipeline safely.
- 06
Token management
Control of API access, cost and usage policy across teams.
See Token Ledger - 07
Customer feedback and bugs
A live loop from customer feedback and defect data to the agents that act on it.
We start with the areas your teams need first.
The rest get built as those teams take on harder work.
Where you start
Maturity and complexity set the scope.
Maturity is how far your teams have come with AI. Complexity is how hard the next step will be. We look at both before we scope any work.
Maturity
How far your teams have come
The agentic thresholdIt sits between stages 02 and 03. A team that cannot say which stage it is in is still on the near side of it.
What it looks like
AI helps one person at a time. Useful, but each gain stands alone.
Common friction
Usage varies from person to person, with no shared prompts or workflows, so gains don’t transfer.
Where the work goes
Coding assistant adoption, shared prompt libraries and personal productivity tools.
What it looks like
The same workflow runs for the whole function, so a gain in one team shows up in the next.
Common friction
Tool sprawl, no owner for the process, gaps between systems, and environments agents can’t run in.
Where the work goes
AI code review, automated reporting and structured workflows for planning and meetings.
What it looks like
AI runs workflows end to end with little human input, and people change the process from what the runs show.
Common friction
Trust gaps, unclear accountability, data infrastructure that isn’t ready, and no governance yet.
Where the work goes
Automated QA pipelines, AI triage of bugs and requests, and agents working in sequence across steps.
What it looks like
Agents work across teams and systems, coordinating with people at scale.
Common friction
Regulatory exposure, model reliability at scale, and an org design not built for AI-native work.
Where the work goes
Agent networks across functions, product delivery that starts from a spec an agent can pick up, and retraining when the metrics drop.
Complexity
How hard the next step is
- Scale
- Headcount, engineering teams and locations.
- Portfolio breadth
- Products, codebases and technical contexts.
- Coordination overhead
- Governance layers, stakeholders and how heavy change control is.
- LowFocused
One product, a small team and fast decisions, with little governance.
- MidScaling
Several products and growing teams, with governance starting to form.
- HighEnterprise
Many products and heavy change control, with alignment needed at every step.
How the work runs
Start with one team, then scale what works.
We prove the flow with one team and learn what works in your codebase, your process and your governance. Then we take it to every team.
- 01Pilot
One team runs the flow end to end. Its skills, agents and rules become the set the other teams start from.
- 02Audit and baseline
A DORA baseline for every team, and an agent-readiness audit of every repository.
- 03Catalyze
Our engineers embed with each team for four weeks, train its champions and fit that set to its code.
- 04Govern
The pilot team becomes your AI center of excellence, with a live KPI leaderboard for every team.
What we measure
- What agents doWhich stages run on skills and agents, team by team.
- How often they do itPull requests per developer per week.
- Whether outcomes improveCycle time and quality against each team’s baseline.
Engineers and product managers get hands-on training along the way. The skills, agents, rules and dashboards live in your repositories and pipelines, and they’re yours at the end.
Case studies
Where we’ve put it to work.
Other services
Seven more ways we put AI to work.
- AI TransformationWe write your AI roadmap, build it, and hand it to your team.
- AI for GTM & FinanceA data foundation for go-to-market and finance, then the agents that run on it.
- Fine-tuning and EvalsModels tuned to your data, and the evaluations that prove they work.
- ML and Enterprise ForecastingForecasting at enterprise scale, like forecasting Black Friday demand to plan staffing.
- AI Cost OptimizationSeeing where AI spend goes and bringing it down without losing quality.
- Custom Agent and App DevelopmentAgents and AI applications built for one workflow and run in production.
- Context and Knowledge GraphsTurning what your company knows into context your AI systems can use.
A viewer can still see the export button. Team rule: actions that move data check the user’s role.
Open