The repository outgrows the prompt
As a codebase grows, no developer or agent can inspect every file, relationship, convention, and previous decision for each change.
Static analysis for AI-assisted development
Build better with your AI agent. Drift less.
Code Buster is a local static-analysis CLI that gives your coding agent deterministic repository evidence while it works. Code Buster itself does not call an AI model or consume model tokens; the agent still uses tokens when it reads findings, inspects code, or makes changes.
brew install tool-bunker/tap/code-busterNative install for Apple Silicon macOS. Rust is not required.
18*Languages
480+Registered rules
7Report formats
0Required cloud services
* Code Buster recognizes 18 source languages. Analysis depth varies by language and rule family. Review current support →
Case status: open
Powerful today. Still evolving.
Use Code Buster for local exploration, AI context, and reviewing changes before handoff. It complements compilers, linters, tests, and specialist security tools rather than replacing them. Until version 1.0.0, do not rely on it as a blocking quality gate in production pipelines.
Repository-aware analysis
Find what your AI agent missed.
Code Buster scans the code and surfaces potential bugs for you or your agent to evaluate and fix.
Green code signals and red potential bugs move toward Code Buster. Each scan pulse visually clears the red markers.
Works withPiOMPCodexClaude CodeCursorand any other coding agent
The context problem
When context overflows, important details disappear.
Large repositories contain more code, conventions, dependencies, and history than a person or an AI agent can hold in view at once. Adding everything to the prompt does not solve that problem - it buries the evidence that matters.
Everything competes for attention
Loading more source, documentation, tool output, and instructions consumes the same limited attention needed to understand the task.
The useful signals get buried
Existing solutions, architectural boundaries, and local conventions are easy to miss. The result may work while still pulling the repository apart.
Code Buster returns focused evidence
Code Buster analyzes the repository and surfaces relevant findings instead of handing you or your AI agent the entire codebase to reason through at once.
Less noise. More signal.How it works01 / CreateAgent changes code 02 / AnalyzeAgent uses Code Buster 03 / DecideAgent judges findings 04 / IterateAgent improves its work
Keep your agent grounded while it works.
Code Buster returns focused repository evidence throughout the task. You or your agent decide what matters and what to fix.
Your preferred coding agent makes a focused change.
The agent runs the narrowest relevant check during the task.
Relevant issues are accepted; bad advice can be rejected.
The agent applies accepted feedback and reruns checks as needed.
Development workflow comparison
The old wayNo context
Developer becomes the feedback system
The AI completes the task, but the developer has to find and explain everything that does not fit.
Developer
“We already have a helper for this.”
Developer
“Why did you bypass the existing component?”
Developer
“This works, but it does not follow our architecture.”
AI
“You're right. Let me try again.”
Repeated prompts, review fatigue, duplicated code, and changes that slowly pull the repository apart.
With Code BusterRepository-aware
Code Buster gives the AI feedback
A developer or agent can run Code Buster before editing and again after a change. The tool reports evidence; it does not inspect, edit, or approve code on the agent’s behalf.
Example finding
“This new implementation matches unchanged behavior in src/shared. Inspect whether the existing function should be reused.”
Example finding
“This dependency violates a configured architecture boundary.”
Example finding
“This change introduces a duplicate source pattern.”
Developer or agent
“I’ll evaluate that evidence against the intended behavior.”
A repeatable review signal that can catch repository-level issues, while the developer remains responsible for design and correctness.
Repository evidence
A problem becomes actionable feedback.
This representative review uses Code Buster’s tested circular-dependency finding. The finding message and evidence format come from the real rule; the agent still owns the remediation decision.
A change closes a dependency loop
The new import works locally, but connects three modules in a cycle that makes the architecture harder to change and test.
a.code → b.code
b.code → c.code
c.code → a.codeThe exact problem is returned
The agent receives a concrete path through the cycle instead of a vague request to “follow the architecture.”
circular dependency:
a.code → b.code → c.code → a.code
confidence: medium
severity: warningThe agent evaluates and corrects
It can move the shared responsibility behind an existing boundary, remove the backward dependency, and rerun Code Buster to confirm the cycle is gone.
a.code → shared.code
b.code → shared.code
c.code → shared.code
cycle removedRepresentative scenario grounded in the tested cycle rule. A clean report does not prove behavioral correctness; tests and human review still matter.
One command. Two moments.
Before and after every change.
Code Buster turns repository analysis into context the agent can act on. Run it before the change to understand the system, then after the change to catch drift before review.
Map the repository
Surface structure, dependencies, configured architecture, hotspots, and repeated implementations before the agent starts editing.
Give the AI evidence
Put relevant findings into the coding workflow so decisions follow the codebase instead of generic assumptions.
Check for drift
Analyze the result for duplication, broken boundaries, dead code, UI inconsistency, and other avoidable decay.
What Code Buster finds
Issues you miss when reviewing one file at a time.
Code Buster examines individual files and relationships across the repository. Each finding shows what it found, where it appears, why it matters, and what you or your agent should inspect next.
Find forbidden dependencies, layer cycles, and changes that cross configured boundaries.
Surface repeated functions and source blocks before parallel implementations spread.
Identify production files and declarations no longer reachable from known entry points.
Expose circular relationships that make modules harder to isolate, change, and test.
Highlight long and complex functions that concentrate review and maintenance risk.
Detect repeated styles, raw values, and bypasses of established design patterns.
Check required directories, misplaced files, and conventions configured by the project.
Apply focused rules with analysis depth appropriate to each supported language.
Model-agnostic by design
Keep your AI. Improve its view of the code.
Code Buster is a local CLI, not another model. Any coding agent that can run a command and understand terminal or JSON output can use its evidence. The named tools below are CLI-compatible examples - not claims of native vendor integrations.
Read the AI workflow →Pi
OMP
Codex
Claude Code
Cursor
Any agent with CLI access
Compatibility requirement: run cb and read its output. Structured JSON and NDJSON are available for automated workflows.
Built in the open
Help improve Code Buster.
Code Buster is MIT licensed. Real repositories make it better: useful rules need positive examples, nearby negative cases, and evidence about false positives.
01 / REPORTReport a finding
Share noisy output or a minimal reproduction of behavior that should be caught.
02 / SUGGESTPropose a ruleDescribe the costly behavior, useful evidence, and cases that must not be reported.
03 / BUILDImprove a languageAdd precise rules, semantic depth, fixtures, documentation, or integrations.
04 / DISCUSSShape the workflowBring a real agent workflow, question, or idea for repository-aware analysis.
Review with less repetitionSpend less time explaining issues