← Back to the blogEvolutions

Simulate a Change Before You Code It

Two harmless-looking changes, one hidden billing conflict. How simulating the impact on a reverse-specified model surfaces it before anyone opens an editor.

September 22, 2026 · 5 min read

Most product changes get approved on a hunch and understood during QA, usually when something breaks two screens away from where anyone was looking. This piece follows two changes through a simulation, from the first ticket to the decision, to show what shifts when you see the impact first.

Two tickets on a Monday

Streamly is a fictional streaming platform, six years old, with a codebase that has outlived most of the people who started it. On the same Monday, two product managers open two tickets.

The first one is “Family Sharing.” An account holder invites family members. Each time someone joins, the subscription price is recalculated, and everything lands on a single invoice sent to the holder.

The second is “Pay in 3.” Customers on the annual plan can split the payment into three installments, and the amount is locked at signup so nobody gets a surprise in month eight.

Two teams, two backlogs, two sprint plannings. Nobody thinks to put the tickets in the same room. Why would they? One is about households, the other about payment terms.

If you have lived through a few release cycles, you can guess what usually happens next. Each team builds its feature correctly. QA finds something odd late in the cycle, or worse, a support agent finds it in March.

Where the fear comes from

Ask any team what happens when you add a payment option to a product of that age, and the honest answer is “we’re not totally sure.” Someone remembers an edge case. Someone greps. A meeting gets booked to scope the impact. Then the team ships with crossed fingers and a long test cycle.

Most of the time, the people are fine and the map is missing. The software grew faster than its documentation, and AI-assisted coding widens the gap every week. Faros AI’s The AI Productivity Paradox report (July 2025, 10,000 developers, 1,255 teams) found that teams using AI merge 98% more pull requests, while review time goes up 91%. More code lands, and each new change sits on top of a system fewer people can describe from memory.

Putting both changes on the map

Simulation only works if there is a map to simulate on. Before Streamly’s two tickets get anywhere near a developer, the platform has already been reverse-specified. Lyriks read the existing code and extracted its features, user journeys, business rules, screens, objects and attributes, and invariants, with each rule linked to the code that implements it.

Each change then walks the same path. It starts as a need in business language. It becomes a solution, then a functional spec (rules, screens, journeys), then a technical spec (modules, data, APIs). At every stage it is compared with what already exists. For each change, the engine reports what it touches, what stays compatible, what conflicts, what someone has to decide, and what you will need to test.

Nobody has opened an editor yet. That matters more than it sounds. A conflict found in a spec costs a conversation, while a conflict found in production costs a conversation plus a fix plus an apology to whoever got billed twice.

01Need02Solution03Spec04Simulation05Code06VerificationYOUR TEAMLYRIKSYOUR LLMWrites theneedPicks asolutionValidatesthe specDecides eachconflictReads thereportCompares every stage with the existing model and reportswhat is touched, compatible, in conflict, to decide, to testSends specover MCPChecks ruleby ruleNothing to code yet: changes stay on paperWrites thecodeFixes eachgap foundDECIDED BEFORE ANY CODEOUT: IMPACT REPORTCODED, THEN CHECKEDOUT: COMPLIANCE REPORT
A change in six steps, by who does what: your team writes the need, picks the solution, validates the spec and decides conflicts; Lyriks compares every stage with the existing model and reports the impact; then your LLM writes the code over MCP and Lyriks checks it rule by rule until every gap is fixed.

Tuesday’s report

Family Sharing goes on the model first. No surprises there. It touches member management, the invoice and the pricing rule. Then Pay in 3 is placed next to it, and the report turns red on one line.

What happens if a holder adds a member between the second and third installment? Family Sharing says the price must be recalculated. Pay in 3 says the amount is locked. Both rules are reasonable alone. Together they cannot both be true.

The report names the two conflicting billing rules and the screens involved, which are signup, member management and billing history. It also lists what is untouched and still compatible, such as the invitation flow, so nobody wastes a day re-testing it. And it ends with the decision in plain words. Recalculate the remaining installments, or defer the price change to the next billing period?

Look at who that question is for. Product and finance, ideally in the same meeting, ideally this week. Certainly not a developer at 7 p.m. the night before a release, picking whichever rule happens to be in the file they have open.

CHANGE A · FAMILY SHARINGPrice recalculatedwhen a member joinsCHANGE B · PAY IN 3Amount lockedat signupBILLING RULETwo rules, one contradictionCONFLICTfound on the model, before the first line of code
Two changes that look unrelated contradict each other on the billing rule; the simulation finds it before any code. Fictional example from the article.

Same question, same answer

You could paste both tickets into a chat window and ask an LLM about the impact. It would answer, often with confidence. Ask again and the answer moves. For impact analysis that is a dealbreaker, because a decision taken on Tuesday has to hold on Thursday when finance asks how you got there.

The simulation engine is deterministic. It is built on graph rewriting, developed in-house, and is patent pending. Ask it the same question twice and you get the same answer. The knowledge base is a graph database where every element points to its source, whether that is a line of code, a Jira ticket or a Confluence page.

In practice, Streamly’s product lead picks “defer to the next billing period.” The team reruns the simulation. The conflict is gone, the report is stable, and comparing Tuesday’s run with Wednesday’s shows exactly which rule changed. When a third change arrives next month, say a student discount, it lands on a model that already knows about the first two.

After the decision, the code

Only now does anyone write code. The validated spec goes to your coding agent (Claude Code, Cursor or Copilot over MCP) with its rules and their sources. The output is then checked rule by rule. Every gap goes back to the agent, and the loop runs until every rule holds. The release ships with a compliance report that sorts each item as compliant, addition, omission or regression. The full workflow is described on the Evolve your software page.

You don’t have to model the whole platform to try this. Pick the area where changes make your team hesitate the most, and run your next change through a simulation before kickoff. If the report comes back boring, good. If it comes back red, you caught it on paper, which is the cheapest place to fix a wrong note.

You can do that on your own code in a demo.

Keep your software in tune

Start with one module. Lyriks recovers its spec, then verifies every change. All it needs is your repository.