GSD (Get Shit Done) is a mature, actively maintained meta-prompting and context-engineering system that orchestrates AI coding agents (Claude Code, OpenCode, Gemini, Codex, Copilot, Cursor, and 9+ other runtimes) through a structured milestone → phase → plan → execute → verify workflow. The system solves context decay in long AI-assisted coding sessions by maintaining a `.planning/` artifact tree (ROADMAP.md, STATE.md, PLAN.md, SUMMARY.md, VERIFICATION.md) and dispatching focused subagents with fresh 200K-token contexts for each discrete task. The codebase is a dual-package npm monorepo: a legacy CJS CLI (`get-shit-done-cc`) and a modern TypeScript SDK (`@gsd-build/sdk`) with a query-registry architecture, runtime-bridge sync primitive, and generated CJS mirrors that keep both surfaces in parity. The architecture is built around a 'thin orchestrator' pattern where slash-command entry points delegate to workflow markdown files that spawn specialized subagents (planner, executor, verifier, researcher, debugger, code-reviewer) via a registry-backed `gsd-sdk query` dispatch layer. The SDK exposes a `GSD` class that composes plan parsing, config loading, prompt building, and session running into `executePlan()` and `runPhase()` calls, with event-stream telemetry and CLI/WS transports. A `synckit`-based synchronous bridge (`executeForCjs`) lets CJS callers invoke async SDK handlers without subprocess overhead. The query registry resolves commands through a multi-strategy topology (exact, alias, dotted, spaced) with native handlers and transparent CJS fallback. What distinguishes this codebase is the obsessive engineering around installer migrations (transactional, with rollback and user-prompt resolution), cross-runtime path projection (PowerShell/cmd/Git-Bash/POSIX), adversarial parser testing (hostile frontmatter/roadmap fixtures), atomic state writes with file locking, prompt-injection scanning hooks, and a changeset-fragment workflow that eliminates CHANGELOG merge conflicts. The test suite is exceptionally thorough — 400+ test files covering mutation-resistant config validation, golden parity between CJS and SDK, security prompt injection, worktree safety, and regression coverage for 3800+ tracked issues. The system supports 15 AI runtimes with runtime-aware artifact layout, model-profile resolution, and per-agent model overrides.
The BMAD Method is an AI-assisted software development framework that provides a modular set of skills (workflows) to guide AI agents and humans through the entire development lifecycle. Each skill is a self-contained unit that can be invoked to perform specific tasks such as brainstorming, creating product requirements, designing architecture, implementing features, reviewing code, and conducting retrospectives. The framework maintains project context in `AGENTS.md` to ensure AI alignment with project-specific rules and supports deep customization via layered TOML configuration. Built for integration with AI-powered IDEs (like Claude Code, Cursor), the system emphasizes evidence-based practices, including validation lenses, memlog-based session tracking, and ticketing integration for work tracking. It also offers web bundle exports for deploying skills as Gemini Gems or ChatGPT Custom GPTs. The architecture features a clean separation of concerns, with skills encapsulating their own documentation, scripts, assets, and tests, while shared utilities handle configuration resolution, memlog logging, and validation. The project demonstrates strong engineering practices through automated validation tools, multi-language documentation, and a structured release process. While it manages complexity through modularity, users should be aware of maintenance risks such as duplicated validation text across skills and the need to place customizations in override directories to prevent loss during updates. Overall, the BMAD Method provides a robust, reusable toolkit for teams seeking to institutionalize AI-assisted development workflows.
go-zero is a full-stack Go microservices framework with an integrated code generation toolchain (goctl). In production, it provides a production-grade HTTP/REST server (rest/) with a middleware chain for authentication, tracing, rate limiting, circuit breaking, and load shedding; a gRPC server/client framework (zrpc/) with interceptors for observability, auth, and timeout; an API gateway (gateway/) that translates HTTP requests to gRPC; and a CLI tool (goctl) that generates Go, TypeScript, Dart, Java, and Swagger code from API definitions, SQL schemas, and protobuf files. The core library (core/) delivers building blocks: configuration loading (YAML/JSON/TOML), structured logging with rotation, Prometheus metrics, OpenTelemetry tracing, circuit breaker (Google SRE algorithm), adaptive load shedding, rate limiting (token bucket, period limit), distributed caching (Redis, in-memory), SQL/NoSQL data access with caching, service discovery (etcd, Kubernetes), concurrency primitives (singleflight, mapreduce, stream processing), and data structures (rolling window, timing wheel, safe map). The architecture is modular, with each package providing clean interfaces and option patterns. The codebase is well-tested, actively maintained, and demonstrates strong engineering craftsmanship.
This repository is the source of specify-cli, the flagship Python CLI of Spec Kit. In production it is a Typer-based developer tool that bootstraps projects for Spec-Driven Development: `specify init` scaffolds a `.specify/` structure, installs shared bash/PowerShell/Python helper scripts, and generates agent command/skill files into 37+ AI coding-tool directories (Claude, Copilot, Codex, Gemini, Cursor, Grok, Qwen, Tabnine, Goose, and more). Beyond scaffolding, the tool manages a layered ecosystem of extensions, presets, bundles, and YAML-defined workflows, plus a self-upgrade path that detects uv/pipx/uvx installations and pulls releases from the GitHub API.
Gentle-AI is a CLI-driven application that manages AI coding agents through installation, configuration, and review workflows. It provides a deterministic engineering environment with features like persistent memory (Engram™), receipt-driven development (RDD) for verifiable code reviews, and telemetry collection. The architecture is modular, separating concerns into CLI commands, agent adapters, components (like Skills and Context7), review transaction logic, state management, and a text-based user interface. The system interacts with external AI agents (Claude Code, OpenCode, Cursor, etc.) via adapter patterns, manages state in $HOME/.gentle-ai, and supports cross-platform operation (Linux, macOS, Windows). Key entry points include the gentle-ai CLI command and TUI screens for interactive workflows.
OpenSpec is an AI-native spec-driven development CLI tool that provides a lightweight agreement layer between humans and AI coding assistants. It manages structured 'changes' with proposals, delta specs, designs, and tasks, supporting 30+ AI coding tools (Claude, Cursor, Devin, Copilot, etc.) by generating per-tool skills and slash commands. The CLI features a store system for cross-repo planning, an artifact graph for tracking change progress, shell completion generation, and a validation system. The codebase is well-structured with extensive test coverage, reusable components (artifact graph, markdown parser, command generation adapters, store foundation), and security-conscious patterns (atomic writes, prototype pollution guards). It is actively maintained with a large community (70k+ stars).
The Agentic Startup repository is a spec-driven development (SDD) framework for Claude Code that enables multi-agent AI collaboration for software development. It provides a structured workflow: specify → validate → implement → test → review → document, with optional skills for analysis, refactoring, debugging, and constitution enforcement. The framework uses three implementation tiers (Direct, Incremental, Factory) selected by an automatic complexity classifier, and enforces quality gates through validation checks, drift detection, and constitution-based governance rules (L1/L2/L3 levels). Key features include progressive disclosure for context efficiency, information barriers to prevent bias, and automatic documentation generation. The system is designed as a plugin-based architecture with 'start' (core workflow) and 'team' (specialized agents) components, storing specifications in .start/specs/ and generating documentation in docs/.
This is a Rust CLI tool called `facts` that implements a fact-driven development workflow. It manages a `.facts` file containing atomic, verifiable claims about a project, each with lifecycle tags (`@draft` → `@spec` → `@implemented`) and optional shell commands for automated verification. The tool provides a rich set of subcommands for listing, adding, editing, removing, linting, and checking facts, along with a terminal UI (TUI) built with Ratatui and Crossterm. It integrates with AI coding agents (Claude, Codex) to verify manual facts via an XML-based verdict protocol, and ships with bundled agent skills for discovery, refinement, and implementation. The project is self-hosting—it uses its own `.facts` file to describe itself—and is distributed via npm, PyPI, and direct install. The architecture is a monolith with clearly separated modules for parsing, writing, ID generation, tag filtering, file locking, and agent communication. The codebase demonstrates strong engineering practices: deterministic round-trip serialization, atomic file writes, advisory locking with stale detection, and a boolean expression evaluator for tag filters. It is actively maintained with a comprehensive test suite and CI/CD pipeline.
CCPM is a structured project management skill for AI agents (Claude Code, Codex, etc.) that enforces a spec-driven development workflow: PRD → Epic → GitHub Issues → Parallel Agents → Shipped Code. The codebase consists of markdown reference documents (plan.md, structure.md, sync.md, execute.md, track.md, conventions.md) and a set of deterministic bash scripts that read project state from .claude/ directory (PRDs, epics, tasks with frontmatter). The system does not contain any runtime code—it is purely a collection of instructions and helper scripts that an AI agent reads and executes. Its architecture is a flat skill structure following the agentskills.io standard, with no external dependencies beyond git, gh CLI, and a GitHub repository. The primary data flows are local file operations (creating/reading/updating markdown files) and GitHub API calls via gh CLI for issue creation, syncing, and closing. The skill is harness-agnostic and works with any compatible agent framework.
Agent OS is a framework for AI coding assistants to establish, discover, and inject project standards and shape specifications. It provides a set of markdown commands (commands/agent-os/) that define workflows for common tasks like discovering codebase patterns, maintaining an index of standards, injecting relevant standards into context, planning product vision, and shaping feature specs. These commands are designed to be consumed by tools like Claude Code and Cursor. The repository also includes bash scripts for installing Agent OS into a project, syncing standards back to a base profile, and shared utility functions. The core value is not executable code but a methodology encoded in instructions and shell scripts that enforce a disciplined approach to spec-driven development with AI agents. The codebase is lean, well-structured, and focused on solving the problem of keeping AI agents aligned with team conventions without heavy tooling overhead.