Cresium Engineering

16 min readEngineering team

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.

Saint Jerome spent more than twenty years turning scattered manuscripts into the Vulgate, the one Latin Bible the whole Church read from for over a thousand years. Our cresium-mode does a much smaller version of the same job: many sources, one text everyone works from.
Antonello da Messina, Saint Jerome in his Study, c. 1475 (detail). National Gallery, London.

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.

Two and a half years of writing our review comments down. The first step took 17 months; the last five took seven.

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 themes
  • skills/Workflow and topic entry points
    • implement/
    • review/
    • author-skill/
    • maintain-standards/
    • money/
    • tenant-safety/
    • …
  • references/Detailed criteria, examples, and review
  • standards/Sources, evidence, and change history
  • docs/Installation and usage

local · each repository

repo/
  • AGENTS.mdRepository instructions and references
  • rules/Example guidance files
    • architecture.mdCode organization and boundaries
    • domain.mdRepository-specific conventions
    • testing.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.

Shared criteria live in the plugin; local guidance spans multiple files in this example layout, not a required directory structure.

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.

Dots from common plugin definitions and repository guidance feed implementation and review; implementation works from its task and code, while review revisits the complete diff.
Implementation and review consult the same sources, with review revisiting the complete diff.

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.

Task and code dots join repository instructions in a reading band, then inform consultation alongside thematic plugin skills; some catalog dots remain because not every task needs every rule.
Reading the task, repository instructions, and existing code informs which thematic skills to consult.

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.