- For every approved behaviour, the test that proves it; for every behaviour without one, the gap.
- What was touched outside the area the spec expected, and the reason the agent recorded.
- New dependencies the change introduced.
- Architecture rule violations and size budgets, checked on every run.
- Exactly one authoritative test per behaviour; overlapping authority is reported as a defect.
- Every tool call, recorded before it was answered, so you can reconstruct what the agent read before it decided.
For architects and tech leads
Decide whether to accept a change without reading every line.
An agent can produce more code in an hour than a person can review in a day. KiwiPow IDE gives you evidence the agent did not author, tied to the behaviours that were approved, so your review effort goes where the evidence points and reading the diff becomes the exception.
Sound familiar?
- The agent's confident summary is the only thing between the change and production.
- Acceptance always rests on at least one signal the agent did not write: facts from language analyzers and the IDE's own rules, never the author grading its own work.
- The tests pass, so the forbidden dependency slipped through.
- Standing architecture rules and size budgets are checked on every run. A violation is not discharged by passing tests: tests prove behaviour was preserved, not that a dependency was permitted.
- The model described a call graph that does not exist.
- Every fact about your code comes from an analyzer built on the language's own toolchain, names the plugin that produced it and is stored per commit. When a capability is missing, the view says so.
- "Read before you edit" lives in a prompt the model sometimes ignores.
- The agent reaches the code only through the IDE's tools, so the rules are enforced, not requested, and hold the same on every engine.
At acceptance
The evidence for one change
What you get
Control before code exists
Pick the behaviours a run delivers and set its size budget up front. A run that falsifies what approval rested on returns to you.
One quality standard
Cognitive complexity with one threshold and three plain levels for every analyzed language. The IDE judges; analyzers only measure.
Unmeasured is not clean
Code no analyzer measured raises nothing and is never counted as passing. Before any analysis, the start page says unanalysed, not zero.
One map with overlays
Modules and their dependencies, overlaid by coupling, size, churn or rule violations, instead of a separate map per perspective.
Direction, not just state
Facts stored per commit let the start page show whether code health is moving the good way, and the worst few functions one click from the code.
Analyzers that cannot crash you
An analyzer runs as its own process over an open, versioned contract. A compiler that panics costs one answer, not your window.
Hold agents and people to the same rules
The agent reads the same stored facts you see, through the IDE's own service, and every query is on the record.