Skip to content

Product in development

Know what a change touches before anyone writes it.

CodeIntelligently is building a digital twin of your software: its code graph, its data and the business rules hiding inside both. Every claim points at the exact code that supports it. Every gap stays visible.

Code structureSymbolsCall chainsData modelsBehaviourBusiness modelRequirements

The problem

Code now arrives faster than anyone can understand it.

An AI agent can write a change in minutes. The review still depends on one person remembering that cancellation checks shipping status, that an old mobile client never sends the new field, and that a nightly export reads the column you are about to change. That knowledge lives in heads and old tickets. When it is missing, the change ships anyway.

  1. RequirementRequire a reason on every cancellation.
  2. ImplementationOrderService.cancel now validates the reason. Tests pass.
  3. ReviewApproved. The diff is small and the reviewer knows this service.
  4. TuesdayMobile 3.2 users cannot cancel. Nobody knew it called this endpoint.

The answer

A twin of the product, built from the code and rebuilt on every push.

Point it at your repositories. It reads one exact commit of each and builds seven connected layers, from files and calls up to business rules and requirements. Select a layer to see what it holds for the order cancellation example.

Code structureSymbolsCall chainsData modelsBehaviourBusiness modelRequirements

Call chains

Entry points and the calls they reach through APIs, jobs and event handlers. Each link is graded confirmed, possible, library or unknown.

POST /orders/{id}/cancel
  → OrderController.cancel
    → OrderService.cancel
      → OrderRepository.updateStatus
      → refunds.dispatch(event) unknown
Three confirmed links, one unknownSee how links are graded
Existing codebase

Start from the code you inherited

The twin recovers a baseline of use cases, stories and rules from what the code already does. Anyone on the team can correct it, and every correction is kept with its author.

New product

Start from a brief

A statement of work or product description becomes proposed use cases and criteria, all labelled intended. The code-backed layers grow as the team builds.

Why you can trust it

Every claim says where it came from.

Most code tools answer with confidence. This one answers with evidence: the kind of claim, the source line behind it, and how sure the link is. A guess is allowed. A guess dressed as a fact is not.

What kind of claim is it?

Four kinds of knowledge that never promote each other. Repeating an inference does not make it verified.

  • Read from codeA parser found it in the captured commit: a route, a column, a guard. The citation opens the line.
  • AI inferenceA model proposed a meaning, such as “this guard is a customer policy”. Useful, and labelled as a guess.
  • IntendedSomeone asked for it: a requirement, a brief, a ticket. It describes what should happen, not what does.
  • VerifiedA test ran against a named build and passed for its inputs. It proves that case, nothing wider.

How sure is the link?

Every edge in the code graph is graded, so a reviewer knows which paths to trust and which to check.

  • ConfirmedThe call resolves to exactly one declaration in the code that was read.
  • PossibleSeveral targets fit, such as an interface with three implementations. Each is shown.
  • LibraryThe call leaves your code for a dependency. The twin records it and does not guess inside.
  • UnknownDynamic dispatch, reflection or an unread repository. The path stops and says so.

It will never tell you a change has no impact while part of the map is missing. It tells you where the map stops.

How delivery works

From question to merged change, with people making the calls.

The twin is the shared context for every step. AI drafts, proposes and writes. People approve the requirement, the plan, the code and the results. No agent can approve its own work.

  1. Understand

    Read the twin around the area you want to change: paths, rules, data and gaps.

    AI drafts · you read

  2. Define

    Write the use case, stories and acceptance criteria against the current model.

    AI drafts · lead edits

    Approve requirement
  3. Plan

    Propose files, symbols, tasks and the impact map. Every criterion needs a task.

    AI proposes · dev reviews

    Approve plan
  4. Implement

    The coding agent gets an approved, version-pinned brief and stops if inputs change.

    Agent writes · dev guides

    Review and merge
  5. Verify

    Test cases trace back to criteria. Results name the build they ran against.

    QA reviews · tests run

    Accept results
  6. Refresh

    The merge becomes a new commit. The twin rebuilds and old approvals are rechecked.

    Automatic

Every push starts the loop again from a fresh twin. Approvals built on the old code are flagged, not silently kept.

One change, end to end

“Require a reason to cancel an order.” Here is what it touches.

The request looks like a two-line change. The twin separates what to edit from what to protect, attaches the path that proves each dependency, and marks the one place it cannot see.

Proposed changeRequire a reason when a customer cancels an order

Direct edits

Code the plan expects to change.

  • CancelOrderRequestAdd a required reason field.
  • OrderService.cancelValidate the reason before the status write.
  • V31__add_cancel_reason.sqlNew nullable column, so historical rows stay readable.

Indirect dependencies

Not edited, but reaches the change. Each comes with the path that proves it.

  • mobile-app 3.2 · CancelButtonCalls the endpoint without a reason. It will start receiving validation errors.CancelButton.onPressapi.cancelOrderPOST /orders/{id}/cancel
  • SupportController.overridePossible caller through an interface with two implementations. Check before rollout.SupportController.overrideOrderOps.cancelOrderService.cancel

Regression only

Must keep working. Needs a check, not an edit.

  • order.isShipped() guardUntouched, but a valid reason must not bypass it.
  • Historical cancellationsRows with no reason must still load and export.
  • NightlyExportJob.runPossible reader of orders. Confirm it tolerates the new column.

The map stops here

Known gaps. The report will not say “no impact” past this line.

  • refunds.dispatch(event)The refund handler is chosen at runtime. Whether refunds need the reason is an open question for a person.

Review the cancellation change

Follow a source citation, check the plan, and decide what the trace supports. This demo uses mock code and telemetry.

OrderService.java · example

if (order.isShipped()) {
    throw new OrderAlreadyShipped();
}

The captured path rejects a shipped order. Preserve this rule when adding reason validation.

Where it stands

Honest status.

This is a product in development, not a launch. The pages here describe the design and use an illustrative order system. When something ships, this section will say so.

Now designing

  • The twin and its evidence model
  • Code graph for Java, JavaScript and TypeScript
  • Baselines recovered from existing code
  • GitHub repositories

Next building

  • Change impact against the twin
  • Plans that cover every criterion
  • A version-pinned brief for coding agents
  • Test cases traced to criteria

Later exploring

  • Runtime traces linked to source versions
  • Exact resolution across repositories
  • More languages and code hosts

Build it with us

Looking for a few teams with real code and real pain.

If your team changes code it cannot fully see, I would like to build this against your problems first.