ACC gives your repository a voice. Boundaries, owners, dependencies, the rules nobody wants to repeat — written in plain Markdown, right next to the code. Any agent can read it. So can you.
acc graph oklch 355 · 155Walk into any ACC repository with any coding agent — Codex, Claude Code, Cursor, whatever comes next — and the project explains itself. It's just the files agents already read, organized so the story is easy to follow. The CLI is a bonus. The repository does the talking.
Any agent reads AGENTS.md and gets it — it's just Markdown. Switch agents whenever you like; the context lives in the repo, not in the chat.
ACC installs into the agent, not the repository. The repo stays a standard AGENTS.md project — remove the skill and the CLI tomorrow and nothing changes. ACC adds to the ecosystem, it never replaces it.
The architecture is derived from what you declare and from what the code actually does — no hand-drawn diagram waiting to go stale.
Every fact is tagged: written by a human, observed in the code, or guessed by a tool. No more confusing opinions with evidence.
No telemetry, no uploads, no scripts run. Safe on repositories you don't fully trust — offline, and quietly so.
ACC is a convention, not a runtime. The repository remains understandable through its files alone, while the CLI provides deterministic shortcuts for navigating context, validating contracts, deriving the graph, and working with memory. Use the CLI when it helps; nothing in ACC depends on it.
Everything an agent needs before touching code — the hierarchy, the contracts, the dependencies — in one focused read. --depth decides how deep it goes.
Catches broken references, missing contracts, and forbidden dependencies before they bite. Stable codes, so you always know what you're looking at.
Who owns a path, what it depends on, and what it's allowed to do — in one glance.
See the architecture as text, mermaid, dot, or json — derived, not hand-drawn.
Affected tests and transitive dependents. Answers "what could break?"
Finds the gap between what's declared and what the code shows — and always asks first. It never rewrites your repo silently.
A starting AGENTS.md for features that don't have one yet. Anything guessed is clearly marked for you to review.
ai driven · rust engine · acc compiler
It automates the boring part of programming. The engine runs the same deterministic tools as the CLI — like another agent working on the project — but focused on one thing only: the ACC documentation. When the engine is on, the coding agent just codes.
The engine works like another agent on the project: it runs the same deterministic ACC tools (acc check, acc build, acc discover, acc memory…), but it only cares about one thing — keeping the ACC documentation in sync with the code. No code changes, no refactors. Just the docs, always current.
ACC installs as an agent skill — the repo stays a standard AGENTS.md repo. Two channels, one source: the skill teaches any agent how to operate; the CLI (npm) is the engine underneath.
Every ACC repo tells the same story, top to bottom: start at the root AGENTS.md, walk into the functionality you need, read its contract and memory — then touch code. No special client, no protocol. Just files in an order that makes sense.
AGENTS.md for project-wide context.AGENTS.md for its boundaries and constraints..acc-memory.md for hard-won knowledge from prior sessions.acc check / acc impact.ACC is careful about where facts come from — written by a human, observed in the code, or guessed by a tool. Each one is tagged, so agents trust the right source and you can review the rest.
A human wrote it — in AGENTS.md. Dependencies, ownership, constraints. When facts disagree, this one wins.
Observed in the code — imports, structure, what's actually there. Even if nobody wrote it down.
A guess, from acc discover or an agent. Never treated as fact until a human says so.
ACC follows the AGENTS.md convention everyone already uses — it doesn't compete with it. The skill reads what the repo already has and adds optional context, never a replacement.
The main interface for agents — plain Markdown with familiar sections: Purpose, Responsibilities, Ownership, Dependencies, Constraints. No schema, no frontmatter.
## Dependencies - src/database - src/logging ## Constraints - Must not depend on src/ui.Authoring guide
Project settings, agent profiles, workflows, and standards. All Markdown, all committed, all readable by anyone or anything browsing the repo.
.acc/config/
├─ config.yaml
├─ agents/architect.md
├─ workflows/feature.md
└─ standards/architecture.md Repository structure
The repo's memory. Gotchas, invariants, things tried and rejected — written down so the next agent doesn't have to rediscover them.
## Gotchas - decode() is non-reentrant. ## Tried & Rejected - Split into a crate; overhead not worth it.Memory semantics
Every problem gets a stable code: ACC022 means the same thing this year as it will next. So when an agent reads the feedback, it knows exactly what's wrong — and what to do about it.
Everything lives on GitHub and npm — MIT licensed, no telemetry, no lock-in.
ACC — Agent Code Context. A convention + optional CLI that makes any software repository agent-native, navigable, and self-describing.
github.com/EnzoVezzaro/agents-code-contextVersioned releases on GitHub with changelogs — every v0.x tagged and documented.
Published to npm: acc-code-context — install with npm i -g acc-code-context.