The unit of a developer's capability is changing — fast.

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.

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"])

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.

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.

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.

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.

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.