The estimate shrank and the cost changed because the work changed.
Focus on what creates the most value
Most of the effort in a project was never in writing code. It is in investigating the legacy system, correlating rules, documenting the domain and specifying. That is the work Clovis takes off the team’s hands, so they can concentrate on what actually matters.
Fixed scope with lower risk
With Clovis a fixed-scope contract gets far easier, because whatever evidence does not support becomes a question, not a guess. The team does not have to guess what the legacy system does or what the business wants: it knows, and records it, before implementing.
You buy value, not hours
What we deliver is value for your business, with engineering of the highest quality. Software is not billed hours: it is behavior that solves a real problem. Clovis makes sure what you pay for is what you get, and not hours spent on assumptions.
The way software gets built has changed. It was not adapted, it was not complemented, it was reinvented. Clovis gives your team what it needs to deliver performance with AI without losing quality or control over the technical and business decisions.
Using AI without governance means delegating your business decisions to someone you do not control.
A coding agent on its own cannot tell a business rule from a defect, or your decision from an implementation detail. It fills the gap with the most plausible answer and moves on.
Copies the defect by imitation
The legacy system has an anomaly. To the agent that is simply current behavior, so it reproduces it. Or worse: it fixes the behavior on its own, and nobody knows it changed.
Plausible answers that do not add up
Every ambiguous gap gets a reasonable choice, made in isolation. Together they contradict each other. The inconsistency only shows up in production, as unexpected behavior.
The rule stays with whoever read the code
Business knowledge was pulled out of the code to produce the delivery and evaporated with the session. Documentation, if it exists at all, comes later, once it is already debt.
Deletes whatever looks dead
Code with no apparent use gets removed on the agent’s own initiative. Nobody confirmed it was actually orphaned, and nobody recorded the removal.
Boundaries drawn for convenience
What counts as a business domain and what counts as a technical layer ends up defined by whatever was easiest to generate in that prompt, not by how the business is designed.
No trace of who decided what
The reasoning lives in a chat log nobody reviews and that disappears with the session. Afterwards there is no way to audit the choice, reuse it elsewhere, or know whose it was.
None of these problems come from the model lacking capability. They are product and architecture decisions the agent had no way to make, and made anyway, because nobody designed where it should stop.
AI development made simple, standardized, with governance in your hands.
What it is
- An orchestration layer on top of a coding agent: it splits the work across specialized agents, assembles the context for each one, controls the session and defines the exit criteria.
- Each agent works with its own clean context. It receives what it needs to see for that slice, and nothing beyond it.
- Reading the intent, writing the documentation and implementing remain the coding agent’s job.
What it is not
- Not a scanner. No proprietary heuristic tries to understand the code in place of the coding agent.
- Not just a chat. Free conversation exists and is useful, but it is transient by design: what steers the project lives in a versioned artifact, not in a conversation log.
- Not one more AI to buy. Clovis orchestrates the agent your developer already uses day to day.
Where Clovis fits
You
Decide what the agent has no way to decide: business rules, domain boundaries, what to do with a defect in the legacy system.
Clovis
Splits the work across specialized agents, assembles the context for each one and defines where to stop and ask.
Your coding agent
The one your developer already uses. It remains the one that reads the legacy code, writes the documentation and implements.
Your repository
Where the output lives: documentation, specs, plans, test scenarios and decisions, versioned and reviewable in a Pull Request.
Clovis sits between you and the agent, not in its place. That is why adopting it requires no change of tool and no extra AI subscription to approve.
Where the output lives
Standardized, versioned artifacts directly in your repository.
The memory of the discovery and of the human decisions
The functional map: domains, dependencies and order
The authoritative documentation for each domain
The specs, plans, test scenarios and tasks for each unit of work
The knowledge sits in files, in Git, reviewable in a Pull Request and reusable by the next agent and the next developer.
DB1 AI Squad. A complete SDLC, across four levels of specialized agents.
Clovis works as a complete squad. Each stage of the work is run by agents with their own context, producing the input for the next stage, in a continuous development process.
Etapa 01
From an abstract intent to a map of business domains.
Entra
- The code to analyze, and the path to the legacy system when there is one
- Business rules and documentation: free text, files, URLs or MCP spaces (Jira, Confluence, wiki)
- System type and critical constraints: target stack, contracts to preserve, fixed schema, testing requirements
Faz
- Investigates the legacy code or the business documentation on several fronts at once
- Correlates screens, endpoints, tables and rules to identify bounded contexts: business domains, not folder structure
- Cites evidence for each inference and rates its confidence level
- Escalates as a decision anything that evidence does not support
Sai
- The functional map: the domains, the dependencies between them and the suggested implementation order
- The memory of the discovery: declared constraints and the record of human decisions, which take precedence over code behavior for every agent that follows
- The list of domains to document and the technical skills to generate
Five levels of control. Five problems prevented.
Escalates instead of assuming
Whatever evidence does not support becomes a question, not a guess. Across the three projects, 39 ambiguous points went up to a human, and none of those questions delayed the delivery.
- 39 escalated decisions
- 0 delays
Clean context per agent
Each agent gets its own slice and nothing beyond it. That is what keeps the agent from losing the thread halfway through a large domain, and what keeps its output predictable.
Knowledge in files, not in chat
Specs, plans, tasks and decisions live in the repository and go through Pull Request, like any other change. A conversation log gets no review and does not survive the session.
Documentation before implementation
The domain is documented in depth before it becomes code, and the spec comes out of that documentation. That is why no documentation debt is left at the end of the cycle.
It does not replace your agent
Clovis orchestrates the coding agent your team already uses. Your developer stays in their own tool, and your company approves no extra AI subscription to make this work.
Four tools you can use at any time, without entering the flow.
Free conversation
An open conversation with the coding agent, with no structured flow and no discovery prerequisite.
- Agent mode: unrestricted, it investigates, edits and runs commands
- Plan mode: read only, it presents a plan for you to review before you tell it to execute
- Transient: the conversation is not saved, and leaving discards the history
Discovery mode
The agent works out scope and acceptance criteria with you and records technical decisions to escalate to the tech lead.
- Start from the need, even a vague one.
- The agent asks short questions until the gaps close; “I don’t know” becomes a pending item.
- With the document ready, you can save it, publish it (Confluence, Azure DevOps Wiki, Jira) or refine it.
Code review
Reviews two local branches or a Pull Request, running the project checks.
- Raises structured findings from the project checks
- You pick which ones to publish on the PR and can edit the text of each comment
- In local mode it consolidates the findings into a file outside version control
Create Pull Request
The agent analyzes the diff between branches and detects the hosting provider.
- Uses the project PR template when there is one, and generates title and body
- Publishes only after your approval and returns the PR URL
- Also available as a shortcut when you close a batch in implementation
One prerequisite: a configured agent
None of the three requires prior discovery, documentation or specification. You can walk into any project and use only the tool you need. The discipline is the same as in the flow: the agent investigates, escalates what it cannot decide and only acts after your answer.
A client you already know, and three projects opened up from the inside.
BRK uses Clovis in production, and that case is published with the client name and the numbers. The three projects that follow stay anonymized, as in the source material: each one brings the starting point, the timeline and the decisions where the agent stopped to ask before moving on.
Named client
One specialist, one copilot and a portal migrated.
The migration started with a single specialist supported by the Clovis CLI, which amplifies what the engineer does instead of replacing them. It ran 4x faster than the traditional method, at 60% of the cost, with no compromise on the standards expected of a service 16 million people depend on.
Other cases
The speed showed up. The cost came down. The governance got stronger.
The speed that showed up and the cost that came down.
- Case BRK4 months with 5 people1 month with 3 people
- Case A~1 month for a pair3 days of work by 1 person
- Case B~3 weeks for a pair2 days of work by 1 person
The governance that got stronger.
- 39 ambiguous points became questions for a human across the three projects
- Business rules, domain boundaries, legacy defects and architecture choices: none of them was settled by assumption
- None of those questions delayed the delivery
The speed did not come from loosening supervision. It came from clearing away the context work, the investigating, documenting and specifying that eats the time of whoever decides. The human steps in where the decision belongs to them, and what they decide becomes a written rule, versioned alongside the code.
O que costumam perguntar
Does Clovis replace the coding agent we already use?
No. It orchestrates the agent your team already uses. Reading the legacy code, writing the documentation and implementing remain the coding agent’s job; Clovis decides what it sees, in what order, and where you step in. The one prerequisite is exactly that: having an agent configured.
How is Clovis different from Copilot, Cursor or Claude Code?
Those tools are the coding agent, and Clovis runs on top of them. The difference is not in writing better code, it is in where the work stops. An agent on its own takes the request and returns the delivery, with the reasoning living in a conversation log nobody reviews and that disappears at the end of the session. Clovis splits the work across specialized agents, assembles the context for each one, escalates to the human whatever evidence does not support, and leaves documentation, spec, plan, tasks and decisions in versioned files in your repository. Your developer stays in their own tool.
If we stop using Clovis, what stays with our company?
Everything it produced, because none of it lives inside Clovis. The functional map, the per-domain documentation, the specs, plans, test scenarios, tasks and the record of the human decisions are versioned text files in your repository, reviewed in Pull Request like any other change. The domain documentation is agnostic of framework and library by design, so it keeps holding for the next developer and for any other agent that enters the project.
Do I have to run the whole flow to use it?
No. Free conversation, code review and creating a Pull Request work outside the flow and require no prior discovery, documentation or specification. You can walk into any project and use only the tool you need at that moment.
How much supervision does this demand from the team?
Supervision happens where the decision is yours, not at every generated line. Investigation, documentation, specification and implementation arrive ready for review, with the reasoning in plain sight. Across the three projects there were 39 escalated decisions in total, and none delayed the delivery.
Where does its output live? Does it vanish when the session closes?
It lives in the repository, in versioned text files: functional map, memory of the discovery, per-domain documentation, specs, plans, test scenarios and tasks. It goes through Pull Request like any other change. Free conversation is the only transient artifact, and that is by design.
Does it work on legacy code with no documentation at all?
That is the most common case. On one project the source code was stored inside database tables, with no repository to clone. The Discovery agent investigates, correlates screens, endpoints and tables to identify business domains, cites evidence for each inference and escalates whatever evidence does not support.
What happens when it finds a defect in the legacy system?
It neither reproduces the defect by imitation nor fixes it on its own. It lays out the possible paths and waits for your decision. That is what happened with an incorrect deletion of answers on one of the cases: the human decision went into the documentation together with the contrast against the legacy behavior, so nobody copies the defect back later.
Can it work on several applications at the same time?
Yes. On one project it handled five applications from the same client in parallel, with architecture decisions applying to all five at once, without losing track of who decided what on which front.
Bring one of your repositories. We run Discovery on it.
A technical conversation with the CLI running. You watch the functional map come out of your own code and the first decisions coming up to you, instead of watching slides.