AI without governance fails fast, and you find out in production.
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.
It decides what the agent sees, in what order, and where you step in.
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 legacy code, 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 the output lives
All in text files, inside the repository itself.
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.
Four agents. Each with one input, one job and one output.
The work does not all go to the same place. Each stage has an agent with its own context, and the output of one is the input of the next. Pick a stage to see what goes in, what it does and what comes out.
Etapa 01
From an unknown repository to a map of business domains.
Entra
- The code to analyze, and the path to the legacy system when there is one
- Business rules on a greenfield project: 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 design decisions, and what each one prevents.
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.
Three 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
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.
Three real projects, three different starting points.
The clients are anonymized; the numbers come from the source material. Each case brings the timeline and also the decisions where the agent stopped to ask before moving on.
The conventional timelines for cases A and B are reference estimates for the scope delivered. The one for case C is the formal project forecast.
The speed showed up. The decision stayed human.
The speed that showed up
- Case A~1 month for a pair3 days of work
- Case B~3 weeks for a pair2 days of work
- Case C3 months with 5 people1 month with 3
The decision that stayed human
- 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.
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.