We build the tooling a team needs to be genuinely productive when AI agents write the code.
The unit of a developer's capability is changing โ fast.
| What "being skilled" meant | |
|---|---|
| Yesterday | The languages ร frameworks ร toolchains you mastered by hand |
| Today | The quality of the agent configuration you carry |
Claude Code and its peers are no longer demos โ they're in real engineering teams. The Agent Skills standard is now supported by 25+ frameworks. A whole product can collapse into one agent plus a thin front-end shell.
We don't think this is the future. It's the present. ProjAnvil is our answer to a single question:
What infrastructure does a team actually need to ship software when an agent is the one writing it?
Every agent's potential is set by three things โ and most teams are leaving two of them empty.
| Element | Decides | ProjAnvil's question |
|---|---|---|
| ๐ ๏ธ Command | What an agent can do | "Where are its boundaries?" |
| ๐ง Skill | What an agent knows | "How deep is its expertise?" |
| ๐ MCP | What an agent can connect to | "Which of our systems can it reach?" |
We discovered that filling these three axes โ with quality over quantity โ changes everything. One precise, compliant skill beats ten generic ones. ProjAnvil is a coordinated toolkit that strengthens each axis, plus the SDKs to build your own.
A complete pipeline for agent-era development: intent โ knowledge โ context โ execution. Each layer has one job and does it well.
flowchart TB
Human(["๐ค Human<br/>uploads PRD & API docs"])
subgraph Intent["๐ฏ Intent Layer"]
Porto["<b>Porto</b><br/>PRD โ grounded specs"]
end
subgraph Knowledge["๐ Knowledge Layer"]
SCV["<b>SCV</b><br/>Codebase โ AI-readable knowledge"]
end
subgraph Context["๐ Context Layer"]
Knot["<b>Knot</b><br/>API docs โ MCP server"]
end
subgraph Skill["๐ง Skill Layer"]
MindForge["<b>MindForge</b><br/>9 agents + 17 skills"]
end
Code(["๐พ Existing codebase"]) --> SCV
Human -->|PRD| Porto
Human -->|API defs| Knot
SCV -->|patterns & conventions| Porto
Knot -.->|API contracts via MCP| Porto
MindForge -.->|empowers every stage| Porto
Porto -->|engineering specs| AgentExec(["๐ค Agent executes<br/>with MindForge + SCV + Knot"])
AgentExec --> Shipped(["๐ Shipped code"])
๐ง Skill Layer โ MindForge
A complete capability toolkit for Claude Code โ the "app store" of agent expertise.
The most-starred repo in the org. Ships 9 specialized agents (code reviewer, frontend engineer, Go/Java/Python engineers, iOS developer, system architect, product manager, test engineers) and 17 composable skills (API design, database design, system architecture, testing, Git mastery, frontend stacks, and more), plus extensible MCP services. One-command install, bilingual (English / ็ฎไฝไธญๆ), template-based creation. Built on a clean separation: *agents define who acts, skills define what they know, MCP defines what they reach.
Why: Generic agents plateau fast. Depth in vertical domains is what turns an assistant into a teammate.
๐ Knowledge Layer โ SCV (Source Code Vault)
Turn any codebase into structured knowledge an agent can actually reason over.
SCV analyzes repositories and emits four purpose-built documents โ README.md (positioning & quick-start), SUMMARY.md (5-minute briefing), ARCHITECTURE.md (Mermaid diagrams & rationale), and FILE_INDEX.md (file-by-file responsibility map). Runs single repos or entire portfolios in parallel via isolated subagents, with incremental skips, auto-pull, and crash recovery. Optional codebones deep-analysis mode strips code to its skeleton (~85% token reduction).
Why: An agent that doesn't understand your existing patterns will reinvent them โ badly. Your team's real asset is its conventions; SCV makes them legible to machines.
๐ฏ Intent Layer โ Porto
A codebase-aware requirements workbench that turns PRDs into grounded engineering specs.
Porto doesn't hallucinate boilerplate. It retrieves context from an SCV-built knowledge base, then drives each spec through a generate โ critique โ refine loop scored on a 12-point rubric (template-grade specs climb from ~3.2 to ~11.4). Every retrieval, tool call, and rework decision is recorded for traceability. And it runs end-to-end with zero API keys โ deterministic fallbacks mean the model is a quality amplifier, not an on/off switch.
Why: The gap between "what product asked for" and "what engineering can build" is where projects bleed. Porto closes it with specs that reference your modules, not invented ones.
๐ Context Layer โ Knot
An API documentation hub that's as readable by AI as it is by humans.
Knot organizes endpoints into searchable, Markdown-rich groups with drag-and-drop ordering, fuzzy search, and JSON highlighting. Its distinguishing trick is a built-in MCP server: Claude can list groups, search APIs, pull detailed docs, and generate request/response examples through natural language. Go backend + Svelte 5 frontend compiled into a single zero-dependency binary, with SQLite / PostgreSQL / MySQL backends.
Why: API docs that only render in a browser are dead weight in the agent era. If an agent can't query your contracts, it can't integrate with them.
An idiomatic Go port of Anthropic's Claude Agent SDK (Python). Wraps the Claude Code CLI to offer one-shot Query()/QuerySync() channels, an interactive ClaudeSDKClient, in-process MCP tools, hooks (e.g. blocking dangerous bash), agent definitions, configurable thinking budgets, sandboxing, and full session management (resume / import / mutations / store / summary). Mirrors the Python SDK's surface so Go teams can build agents without leaving their stack.
A community Go port of LangChain โ core/ (messages, runnables/LCEL, tools, prompts, output parsers, vector stores, retrievers, callbacks, streaming), langchain/ (CreateAgent with 15 middleware modules, structured output, interrupts/resume, subagents), textsplitters/, and partner integrations for OpenAI, Anthropic, Ollama, and Chroma. 920+ tests passing across 51 packages. Preview quality (v0.3.x), MIT, not affiliated with LangChain, Inc.
Why: The Go ecosystem deserved first-class agent primitives โ not a "just call Python" workaround.
Scaffolds AI-native apps for Claude Code โ not plugins, webhooks, or wrappers, but tools that live inside the agent's context. belt new walks you through building a four-part bundle (Skill SKILL.md + executable Script + subagent + reusable Component), bilingual by default, with one-command install into ~/.claude/. Includes a component system where logic is pytest-verified before the AI ever touches it.
Why: "A product is an agent plus a thin shell." Belt is the fastest way to build that shell.
Jiade (ๅ็ โ "simulated")
Generates runnable microcosms of real-world industry systems โ complete, small-scale architectures for learning, demos, integration testing, and tooling experiments. The bundled bank template spins up 7 Go microservices and 7 PostgreSQL databases on a single instance, with deterministic seed data (same seed โ byte-identical rows), three-factor event streams, and cross-database federation via postgres_fdw. Self-contained output runs with just Docker and Go.
Why: Agents need realistic systems to build against. Jiade gives you a believable bank, reproducibly, in one command.
A self-hosted, privacy-first ChatBI platform.
Ask questions in plain language and get SQL, tables, and charts over your own databases โ without your data ever leaving your infrastructure. Bring-your-own-LLM (a fully local model via Ollama, or any OpenAI-/Anthropic-compatible endpoint), a rule-based semantic layer, SQL guard, and EXPLAIN-based cost gate keep the deterministic parts predictable, while an 8-role LLM agent pipeline (intent, planning, SQL gen/rewrite, insight, โฆ) handles the rest. Python/FastAPI backend + Next.js frontend, ships with a synthetic banking demo dataset generated with Faker.
Why: The best proof of an agent stack is a real product built on it. Bossy shows the toolkit paying off end-to-end โ a working, self-hosted ChatBI app where your data never has to leave your infrastructure.
The human does what humans do best โ intent and judgment:
๐พ Existing code โโโบ SCV โโโบ structured knowledge base
๐ PRD document โโโบ Porto โโโบ grounded engineering specs
๐ API definitions โโโบ Knot โโโบ AI-readable API context
The agent does the rest โ execution โ equipped with all three axes filled:
โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโ
โ MindForge โ โ SCV โ โ Knot MCP โ
โ domain โ โ code โ โ API โ
โ expertise โ โ knowledge โ โ contracts โ
โโโโโโโโฌโโโโโโโ โโโโโโโโฌโโโโโโโ โโโโโโโโฌโโโโโโโ
โโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโ
โ Understands the โ
โ spec โ writes code โ
โ โ reviews โ tests โ
โโโโโโโโโโโโโโโโโโโโโโโ
The result: specs stop being guesswork, code stops reinventing your conventions, and APIs stop being invisible to the agent writing against them.
We kept watching talented teams adopt coding agents and hit the same three walls: the agent didn't know their domain, didn't know their codebase, and couldn't reach their systems. Most "AI productivity" effort goes into prompting. We think the bigger leverage is in infrastructure โ filling the Skill, Knowledge, and Context axes so any agent becomes dramatically more useful, immediately.
ProjAnvil is that infrastructure, built in the open, MIT-licensed, and dogfooded on every project we ship. We're betting that the teams who win the next decade won't be the ones with the most coders โ they'll be the ones with the deepest, most proprietary agent configurations.
| Repo | Role | Language | What it does |
|---|---|---|---|
| MindForge | ๐ง Skill | Go | 9 agents + 17 skills + MCP services for Claude Code |
| SCV | ๐ Knowledge | Python | Codebase โ 4 structured, AI-readable documents |
| Porto | ๐ฏ Intent | Python | PRD โ grounded, self-refining engineering specs |
| Knot | ๐ Context | Go ยท Svelte | API docs hub with a built-in MCP server |
| claude-agent-sdk-golang | ๐งฑ Foundation | Go | Go port of Anthropic's Claude Agent SDK |
| langchain-golang | ๐งฑ Foundation | Go | Community Go port of LangChain |
| Belt | ๐ง Tooling | Python | Scaffolds AI-native apps for Claude Code |
| Jiade | ๐ง Tooling | Go | Generates runnable miniature industry systems |
| Bossy | ๐ Application | Python ยท TypeScript | Self-hosted, privacy-first natural-language BI over your databases |
Quality over quantity. One precise skill beats ten generic ones.
Built by humans, for agents. โ๏ธ