Stele before the plan · Prism before the edit · Shale after it

Questions your coding agent can't answer alone.

Your coding agent hands you a diff. It does not say whether the change breaks something you decided, whether it reached every place it had to, or what the agent did and checked. Three local, open-source tools answer one question each.

before the plan · preview

Stele

Does this break what we decided?

Checks every requirement against every one approved before it, and hands the agent the approved requirements a request touches. A request that cannot keep one makes the agent stop and ask you.

  • Reads Spec Kit, OpenSpec, Kiro or plain Markdown
  • A model proposes each contradiction; a solver confirms it
  • You approve in one prompt. Works with Claude Code
brew install provasign/tap/stele
before the edit · v1.1

Prism

Did it change everything it had to?

Every caller, override, implementation and test a change affects, resolved by the language's own compiler, not grep. Prism answers; the agent edits.

  • Change work, 32 tasks: all solved (native 31), 24% lower task cost, 35% fewer agent steps
  • Bug fixes, 40 real issues: same results, 8% lower task cost, 15% fewer agent steps
  • Claude Code, Codex, Cursor, Copilot, Gemini CLI, OpenCode, Windsurf
brew install provasign/tap/prism
after the edit

Shale

What did the agent actually do?

Records the agent session (intent, files touched, checks run, model and cost) and renders it as a card reviewers read before the diff. Gaps are shown, never hidden.

  • Five minutes to set up: no account, no server
  • Works across coding agents
  • A real card on a live demo PR
brew install provasign/tap/shale

What you decided stays decided.

Requirements written months apart contradict each other, and an agent builds whichever one it reads. Stele turns each requirement into a rule it can check, finds the ones that cannot all hold, and asks you. What you approve lives in the repository, and every later request is read against it.

A Claude Code session with Stele: the owner states a rule and approves it in a permission prompt; a later request that breaks the rule makes the agent stop and ask
You say it once.

"A member must never hold more than 3 books." The agent writes it down as one requirement, and Stele checks it against everything approved before.

You approve, not the agent.

Claude Code asks you to allow the one command that records the approval, with Stele's summary in the prompt.

A request that breaks it is caught.

"Staff may hold up to 10." The agent quotes the requirement in the way and asks what should hold, before it edits anything.

The hooks cost no model calls.

Looking up the requirements a request touches takes milliseconds. A model reads a requirement once, when it is written or changed.

A real Claude Code session on a small example project, with the waiting cut. Stele is a preview: it works with Claude Code, and its measured accuracy is uneven and published.

Know the whole change before you touch it.

Prism turns the multi-step investigations developers and agents repeat every day into task-shaped operations with explicit completeness. It works with Claude Code, Codex, Cursor, Copilot (VS Code), Gemini CLI, OpenCode, and Windsurf, as an MCP server or as a prism command the agent runs in its shell.

prism · change-impact · real output on gin
$ prism change-impact ResponseWriter.Status

completeness: closed (compiler-backed go)
editSites (14)
  response_writer.go:30:2   Status() int
  response_writer.go:98:26  func (w *responseWriter) Status() int
  gin.go:770:17             if c.writermem.Status() == code
  logger.go:301:31          param.StatusCode = c.Writer.Status()
  ... 10 more in tests
not this change   17 lines calling Context.Status
                  9 comments and docs

Measured against native Claude Code.

Measured on Prism 1.0 (v0.87.39) against Claude Code's own tools, Sonnet 5.5, on two task sets: 32 change tasks and 40 real bug-fix issues. The current release is v1.1.2. The tasks, run records, transcripts, and limits are public.

Change work: 0.76× cost

32 renames and signature changes in Python, Java, TypeScript and Go. Prism solved all 32 (native 31) with 0.65× the tool calls. About 22% cheaper over a working session.

Bug fixes: 0.92× cost

40 GitHub issues filed after the model's training cutoff. Same results as native (25 vs 23 solved, within noise) with 0.85× the tool calls. About 8% cheaper over a session.

Open evidence

Tasks, raw agent records, and transcripts live in the public Research repository.

Make the result explain itself in review.

Shale turns the agent session into a compact evidence card that travels with the code. It shows what is known and what is missing.

A Shale session: intent, edits, checks, completion, and evidence publication
github-actions bot commented
Shale · 1 session · claude-code
60k tokens · 2 iterations · < 1 min
Intent
Add rate limiting to the login endpoint
Token bucket per client IP. Return 429 with Retry-After.
Changed files (3) · all with evidence
ratelimit.goverified
ratelimit_test.goverified
main.goverified
Checks recorded locally
go test ./...passed
Advisory · CI is authoritative.

The evidence format is real. See the live demo pull requests.

Local tools. Open evidence.

Each tool works on its own and fits the tools developers already use. There is no shared account or hosted control plane. Where two are installed they work together: the requests an agent declares with Shale can become requirements Stele checks, and Shale shows on the pull request what a change does to those requirements.

Local first

Code analysis, approved requirements and session capture stay with the repository and developer workflow.

Measured claims

Correctness results are tied to published tasks, independent oracles, and raw runs.

Honest boundaries

Unsupported analysis and missing evidence are labeled instead of silently promoted to certainty.

Under Prism: Grove. Prism embeds Grove's code graph. Grove remains available to tool builders, but Prism users do not install or configure it separately.