How we securely scaled agentic coding in the fintech industry
How we standardized our coding practices across every repo, so code written by people and by agents is held to the same bar.

We’re living through a strange moment in software development. LLMs have made us exponentially more productive over the last few years, but they’ve also brought a massive problem of scalability, maintainability, and slop.
At Cresium, we hold one policy that is non-negotiable, built on three principles:
- Code must be scalable, clear, and maintainable.
- Every line that ships is reviewed and fully understood by the person who shipped it.
- Long-term scalability wins over short-term speed.
We’re a fintech. We can’t afford to disrespect our codebase by shipping products when we don’t know what they do under the hood, and we can’t hand our customers’ money over to an LLM’s judgment. We’re audited by financial institutions, and the entire business runs on what Engineering builds. Everything we merge and deploy to production demands meticulous, obsessive attention to detail.
For us, the problem is amplified by how our codebase is split. We don’t run microservices. Mage, our backend, and Druid, our frontend, are each closer to a monolith, with several services living inside each one, and they sit in separate repositories. Next to them are two much smaller repos: Knight, which handles onboarding, and Archer, our notifications service.
To be clear, running all of this locally is a solved problem for us. Any engineer can spin up the whole stack with a single command and have it working end to end. Local infrastructure isn’t what slows us down. The real challenge is keeping standards consistent across repositories when AI agents are writing most of the code.
A monorepo can look like a way out, and in the short to medium term it might ease some of the friction. But in the long run it doesn’t scale for us: ownership gets blurry, responsibility gets diluted, and shipping becomes harder rather than easier. Keeping separate repositories is a deliberate choice, and we accept the trade-off: standardization is harder today in exchange for scalability tomorrow.
That put us in front of a hard question over the past few months: how do we move at a truly competitive speed without lowering the code standards we hold across every service?
Discovery
The path
This problem isn’t new to us. Before we landed on what we use today, we went through a series of partial fixes, each one catching a little more than the one before.
The first was a husky pre-commit hook, added to Druid, our frontend, in April 2024. Before every commit it ran the formatter and the linter’s autofixes. That kept formatting out of code review, but it caught none of what reviewers actually commented on. In September 2025, came our first AI rule: a five-line Cursor rule, written in Spanish, about how to wrap icons in the frontend. In March 2026 we gave Druid a proper AGENTS.md with seven rule files behind it, and a week later an agentic review in CI. Anyone can trigger it on a pull request, and it reviews the diff against a prompt of our conventions. One of those lines was “Use Decimal.js for money”, because native JavaScript arithmetic loses precision on amounts, and reviewers kept having to say so.
Then the rules started to pile up. Every time a reviewer caught something new, it became another paragraph, and Druid’s rules grew from about 540 lines in April to over 1,500 by October, across 14 files. More rules didn’t make the agent better. So we stepped back and went through the comments reviewers had left on our past pull requests, pulling out the ones that came up again and again. Many of them needed no judgment at all. “Use Decimal for money” is a pattern a linter can find, so it became a custom ESLint rule, money-requires-decimal, alongside five others like no-unnecessary-cast and no-enum-string-literal. In Mage, the mechanical rules moved into the linter too, and the written ones were split into a common layer any backend repo could copy and a layer that only applies to Mage. When we turned the new rules on in Druid, they found 776 existing violations across 374 files. What a reviewer used to catch in some pull requests, the build now catches in every one.
The same review made it clear that the codebase itself was part of the standard. Agents use existing code as a reference, including patterns we no longer want repeated. When the code and the written guidance disagree, adding another instruction doesn’t fix it. Keeping good examples and removing obsolete patterns became part of how we work with agents, alongside improving the rules we give them.
That left a new question: how do you keep one standard in sync across every repo without copying it by hand?
Solution
We moved the standards into Cleric, our shared tooling repository, and split them by how they’re applied. Conventions a machine can check live in our ESLint and formatting configurations. Guidance that needs engineering judgment lives in cresium-mode, a plugin we use for implementation and review in every repository.
The plugin holds 99 shared rules across 11 themes, organized into focused skills and references. Each repository keeps its own architecture, domain-specific conventions, and verification commands in its instructions and supporting documents. A library doesn’t need controller guidance because it runs on Node, and a frontend task doesn’t need backend service conventions.
shared · cleric
plugins/cresium-mode/catalog.jsonShared criteria and themesskills/Workflow and topic entry pointsimplement/review/author-skill/maintain-standards/money/tenant-safety/…
references/Detailed criteria, examples, and reviewstandards/Sources, evidence, and change historydocs/Installation and usage
local · each repository
repo/AGENTS.mdRepository instructions and referencesrules/Example guidance filesarchitecture.mdCode organization and boundariesdomain.mdRepository-specific conventionstesting.mdVerification commands and practices
Read repository instructions and code, then consult relevant plugin skills; local guidance can live in multiple files, wherever the repository keeps it.
This gives us one source without making every repository identical. A change to a shared convention belongs in Cleric. A decision specific to payments, onboarding, or a frontend feature stays with the code it describes.
The same criteria for implementation and review
Implementation and review consult the same rule definitions. We enter review explicitly through review, both locally and in CI. It consults the shared plugin alongside repository-local guidance instead of keeping a separate standard in its prompt. Review revisits the complete diff and the guidance relevant to the changes, rather than assuming the initial implementation context is enough.
This matters most for decisions a linter can’t settle. A parameter limit can flag one kind of complexity, but it can’t tell whether a service method is one coherent operation. Nor can it decide whether extracting a sub-service would make the code easier to understand. Those decisions need criteria and examples, including cases where keeping the logic together is the better choice.
Each rule records where it came from. That helps us tell an agreed convention from a suggestion made in a single review. It also gives us context when we revisit the decision.
Relevant guidance for each task
We start implementation explicitly through implement. It reads the repository’s instructions and existing code, then consults the thematic skills relevant to the task. The task and what we find in the code guide that consultation.
This follows the approach in Anthropic’s context engineering guidance. But Vercel’s evaluations show why packaging content as a skill isn’t enough: an agent may never read a skill it has available. So we verify installation separately from consultation: on real tasks, we check which skills the agent reads and how it applies them. Having the content in the plugin is different from getting the right content into the agent’s context.
Maintaining the standard
A shared standard needs a way to evolve without turning every review comment into a new instruction. The plugin includes a maintenance workflow for concrete changes and gaps: a convention that evolves, a scope that needs adjusting, or guidance that conflicts.
Before adding guidance, the workflow checks whether an existing rule already covers the problem. It also checks whether the change belongs in the shared standard at all. New or revised criteria need a clear scope, a rationale, examples, and counterexamples. Policy changes require a maintainer’s approval; agent feedback is evidence for the team to weigh.
The workflow also checks how guidance works on real tasks: whether agents consult the pertinent skills and apply their criteria consistently during implementation and review. A missed consultation or a rule that doesn’t fit a concrete case is evidence to examine, not a reason to add another instruction automatically. Engineers still decide which lessons become part of the standard.
Conclusion
The order matters. Start with the codebase the agent will use as a reference. Make the intended structure clear, keep good examples, and remove patterns you no longer want repeated. Then automate the checks that can be defined precisely, and document the decisions that still need context.
The mistake we’d skip is treating every repeated correction as a request for more instructions. Some reveal a gap in the tooling. Others point to inconsistent code, or to a decision the team hasn’t agreed on. A longer rules file doesn’t solve all of those problems.
A shared standard gives us a way to maintain those decisions across repositories and apply them during both implementation and review. It doesn’t replace the engineer’s responsibility for the result. The point is to spend less review time repeating conventions, and more time understanding behavior, checking domain decisions, and deciding whether the change is one we want to maintain. Remember: slop isn’t something that happens to you. It’s something you let happen.