MetaSpec (ACNet-AI) — Summary

MetaSpec is a Python meta-specification framework that generates complete "speckits" — autonomous spec-driven toolkits for any domain — from a single metaspec init command. Where other frameworks in this corpus apply SDD to software development, MetaSpec applies SDD to the act of creating SDD toolkits themselves, making it recursive: MetaSpec uses SDS (spec-driven specifications) + SDD (spec-driven development) to build itself, and generates speckits that in turn carry domain specs. It ships a Python CLI (metaspec) with 6 subcommands and a Jinja2 template engine producing CLIs, parsers, validators, AGENTS.md files, and slash-command templates for any domain (development, design, testing, operations, etc.). A key engineering innovation is "precision-guided navigation" — every large template begins with a line-number navigation index so AI agents can read just the relevant 20–50 lines rather than thousands-line files, claiming 84–99% token reductions. MetaSpec is closest to openspec in the seed set (both ship a multi-command CLI for spec pipelines) but differs fundamentally by operating at the meta-level: instead of applying SDD to a feature, it applies SDD to generate a new SDD toolkit for any domain.

MetaSpec (ACNet-AI) — Origin & Philosophy

Origin

Created by ACNet-AI, an organization focused on AI agent tooling. The repo's author lineage traces to building spec-kit and OpenSpec first ("Phase 1: Universal SDD Tools"), then discovering domain-specific specifications are needed ("Phase 2: The Domain Insight"), and finally realizing the meta-framework should generate domain-specific toolkits ("Phase 3: Beyond Development"). Status: Alpha, last commit November 2025, 47 stars, 1 contributor.

Core Philosophy

Two foundational principles per README:

Domain Refinement: "Specifications refine from general to specific through multiple levels. Example: Development Spec → MCP Development Spec → Weather Query MCP Spec. Each level adds more context and constraints, enabling more precise AI guidance."

Modular Composition: "Specifications are independent, reusable modules that can be composed in two ways: Compose specs (combine sub-domain specs into a complete domain spec — Full-stack Web = Frontend + Backend + Database) and Compose usage (apply multiple specs to one project — MetaSpec uses SDS + SDD; MCP project uses MCP + Python + Testing)."

Manifesto-style Quotes (verbatim)

"MetaSpec is a meta-specification framework that enables AI Agents to automatically generate production-ready speckits (Spec-Driven X toolkits). Define your speckit once → Get complete development environment with CLI, parser, validator, templates, and AI agent support."

"MetaSpec 0.5.4 introduces precision-guided navigation so AI agents can read just the slices of large command templates they need... Real-world scenarios show 84-99% token reductions."

"This pattern isn't limited to software development... Any domain can benefit from specification-driven workflows."

Key Innovation

The "precision-guided navigation" pattern: every enhanced command template includes a structured table mapping section → line-number range → recommended read_file(offset, limit) call, enabling AI agents to surgically read only the relevant section of a multi-thousand-line spec template.

MetaSpec (ACNet-AI) — Architecture

Distribution

Python package, installed via pip/uv from GitHub (not yet on PyPI as of analysis date).

Install

# Recommended
uv pip install git+https://github.com/ACNet-AI/MetaSpec.git

# Or pip
pip install git+https://github.com/ACNet-AI/MetaSpec.git

# Development
git clone https://github.com/ACNet-AI/MetaSpec.git && cd MetaSpec
uv pip install -e .

Required Runtime

• Python >= 3.11
• uv or pip

Directory Structure (source repo)

src/
└── metaspec/
    ├── __init__.py
    ├── cli/             # click-based CLI entry points
    ├── generator.py     # speckit generator engine
    ├── models.py        # data models
    ├── registry.py      # community speckit registry client
    ├── templates/
    │   ├── base/        # base templates shared across speckits
    │   ├── library/     # component library templates
    │   └── meta/
    │       └── sdd/
    │           └── commands/
    │               ├── specify.md.j2       # 3000+ line Jinja2 template
    │               ├── implement.md.j2     # 2000+ line Jinja2 template
    │               ├── tasks.md.j2
    │               └── plan.md.j2
    └── validation.py    # speckit validation logic
memory/
└── constitution.md      # constitutional principles for MetaSpec itself

Generated Speckit Structure (output)

<speckit-name>/
├── cli/               # Generated CLI (Python + click)
├── parser/            # Generated spec parser
├── validator/         # Generated spec validator
├── templates/         # Domain-specific spec templates
├── AGENTS.md          # AI agent guide for the speckit
└── <name>-constitution.md  # Domain spec principles

Target AI Tools

Multi-tool — AGENTS.md files are generated for Claude Code, Cursor, and other MCP-compatible agents. Speckits include slash-commands for both Claude Code and Codex CLI.

MetaSpec (ACNet-AI) — Components

CLI Commands (6 total — metaspec binary)

Template Commands Generated in Speckits

Each generated speckit includes slash commands derived from Jinja2 templates. SDD-type speckits include:

• specify — define toolkit implementation specifications
• implement — implementation guidance with language-specific sections
• tasks — task management
• plan — planning

SDS-type speckits include separate specification definition commands.

Jinja2 Templates (key source templates)

Memory / Constitution

• memory/constitution.md — three-part constitutional document defining: Part I (Project Core Values), Part II (Specification Design Principles), Part III (Implementation Standards)
• This file is referenced from AGENTS.md as the supreme governing document

No Hooks / No MCP Servers

MetaSpec itself ships zero Claude Code hooks or MCP servers. It generates speckits that may include hooks and MCP configurations for the generated domain toolkit.

MetaSpec (ACNet-AI) — Uniqueness & Positioning

differs_from_seeds

MetaSpec is closest to openspec in the seed set (both implement multi-command CLI spec pipelines), but operates at a fundamentally different abstraction level: where openspec applies SDD to a software feature, MetaSpec applies SDD to generate a new SDD toolkit for any domain. This recursive "meta-framework" property is unique in the corpus. Versus spec-kit (Python CLI with hooks), MetaSpec has no hooks and targets toolkit generation rather than feature implementation. The precision-guided navigation pattern (line-number tables of contents embedded in templates so AI agents can stream only relevant slices) has no equivalent in any seed framework.

Unique Positioning

The only framework in this batch that generates spec frameworks rather than applying spec frameworks. By separating SDS (specification definition) from SDD (toolkit implementation) as distinct namespaces, MetaSpec enables domain-specific specification systems to be built with the same methodology used to build any other software system.

Observable Failure Modes

1. Alpha quality: status explicitly "Alpha"; generated code quality varies.
2. Not on PyPI: install from GitHub only; brittle dependency management.
3. Single maintainer: 1 contributor; CHANGELOG shows rapid iteration risk.
4. Recursion complexity: the meta-level concept is difficult to explain to new users; README is verbose and conceptually dense.
5. Token optimization is partially documented: the navigation guide pattern works only if agents support read_file(offset, limit) — not all AI tools do.

Explicit Antipatterns (from constitution)

• Using generic SDD specs when domain-specific specs are needed
• Conflating SDS (specification definition) with SDD (toolkit implementation)
• Creating monolithic specs instead of modular composable specs