specweave
Autonomous AI Development Framework. Build production software with specs, tests, and docs that write themselves. Works with Claude, Cursor, Copilot.
Stars: 58
SpecWeave is a spec-driven Skill Fabric for AI coding agents that allows programming AI in English. It provides first-class support for Claude Code and offers reusable logic for controlling AI behavior. With over 100 skills out of the box, SpecWeave eliminates the need to learn Claude Code docs and handles various aspects of feature development. The tool enables users to describe what they want, and SpecWeave autonomously executes tasks, including writing code, running tests, and syncing to GitHub/JIRA. It supports solo developers, agent teams working in parallel, and brownfield projects, offering file-based coordination, autonomous teams, and enterprise-ready features. SpecWeave also integrates LSP Code Intelligence for semantic understanding of codebases and allows for extensible skills without forking.
README:
The spec-driven Skill Fabric for AI coding agents. Program your AI in English. Ship features while you sleep.
First-class support for Claude Code — compatible with any LLM-powered coding tool.
npm install -g specweave # Requires Node.js 20.12.0+Skills are programs written in English — not prompts, not templates, but reusable logic that controls how AI thinks, decides, and acts.
Without SpecWeave: With SpecWeave:
───────────────── ───────────────
"Use React Hook Form with Zod..." "Add a login form"
"Remember, we use Tailwind..." → AI already knows your patterns.
"Don't forget the test pattern..." → It remembered from last time.
"Wait, I told you this yesterday..." → Fix once, learned permanently.
Each skill is a programmable AI behavior you can customize without forking. Fix once, remembered permanently. 100+ skills ship out of the box — PM, Architect, QA, Security, DevOps, Frontend, Backend, Mobile, ML.
You don't need to learn Claude Code docs. SpecWeave handles hooks, plugins, CLAUDE.md, and context management for you. Install, describe your feature, skills do the rest.
Just describe what you want. SpecWeave handles the rest.
You: "Build me a checkout flow with Stripe"
↓
SpecWeave asks 5-10 clarifying questions
(What payment methods? Guest checkout? Subscriptions? Which UI library?)
↓
Creates: spec.md → plan.md → tasks.md
↓
You: "Go ahead and build it"
→ autonomous execution for hours
(writes code, runs tests, fixes failures, syncs to GitHub/JIRA)
↓
You wake up. Review finished work.
Tests cover technical correctness. You check the UI and UX.
↓
You: "Looks good, ship it"
→ validated, documented, shipped.
Solo developer:
You: "I need user authentication with OAuth and magic links"
→ SpecWeave interviews you, creates spec + plan + tasks
You: "Build it"
→ AI works autonomously for hours
You: "Ship it"
→ reviewed, validated, done.
Agent team (parallel):
You: "Build an e-commerce MVP"
→ SpecWeave splits into auth, payments, catalog
→ 3 agents work in parallel across iTerm/tmux panes
Brownfield project:
You: "Migrate the checkout page to React"
→ SpecWeave analyzes existing code, plans strangler fig migration
→ TDD-first autonomous execution
Under the hood — SpecWeave auto-activates these skills from natural language:
| You say | SpecWeave runs |
|---|---|
| "Build me X" |
/sw:increment → spec + plan + tasks |
| "Go ahead" / "Build it" |
/sw:auto → autonomous execution |
| "Ship it" / "We're done" |
/sw:done → quality gates + close |
| "Split this into teams" |
/sw:team-lead → parallel agents |
| "Review the code" |
/sw:grill → critical code review |
You can also invoke commands directly for fine-grained control.
AI coding agents are powerful individually. Run three of them on the same codebase and you get conflicts, duplicated work, and zero traceability.
SpecWeave solves this with file-based coordination:
.specweave/increments/0001-oauth/
├── spec.md ← WHAT: User stories, acceptance criteria
├── plan.md ← HOW: Architecture decisions, tech choices
└── tasks.md ← DO: Implementation tasks with tests
Programmable AI — Skills are programs in English. Customize any skill's behavior via skill-memories/*.md without forking. Your rules override defaults. Original skills keep getting updates.
Autonomous Teams — Run agent swarms across iTerm/tmux panes. Each agent owns an increment. File-based coordination prevents conflicts. Work on auth, payments, and notifications simultaneously.
Enterprise Ready — Compliance audit trails in git. Brownfield analysis for legacy code. Bidirectional sync with GitHub, JIRA, Azure DevOps. Multi-repo coordination. Production-grade from day one.
Run multiple AI agents on the same repository — locally, in the cloud, or with OpenClaw. Each agent owns an isolated increment. No conflicts.
iTerm2 / tmux split panes:
┌──────────────────┬──────────────────┬──────────────────┐
│ Agent 1 (auth) │ Agent 2 (payments)│ Agent 3 (catalog)│
│ /sw:auto │ /sw:auto │ /sw:auto │
│ ████████░░ 80% │ ██████░░░░ 60% │ ████░░░░░░ 40% │
└──────────────────┴──────────────────┴──────────────────┘
/sw:team-lead "feature" splits work → each agent runs /sw:auto → quality gates ensure consistency → progress syncs to GitHub/JIRA.
SpecWeave is built for the reality of enterprise development.
- Compliance audit trails — every decision tracked in version-controlled spec files. SOC 2, HIPAA, FDA ready.
- Brownfield excellence — automated codebase analysis, strangler fig migrations, knowledge preservation. 90%+ of enterprise work is brownfield.
- Multi-repo coordination — specs reference cross-repo dependencies. Agent teams work across repositories.
- External sync — GitHub Issues, JIRA, Azure DevOps — bidirectional, real-time. Local-first, works offline.
- Multi-environment — dev, QA, staging, UAT, production deployment pipelines.
AI agents waste tokens on grep — slow, noisy, full of false positives. SpecWeave ships with LSP integration that gives agents semantic understanding of your codebase.
Grep (text search) LSP (semantic)
────────────────── ──────────────
Speed: 69ms 0.35ms (198x faster)
"read" symbol: 254 matches 32 references
False positives: 222 noise results 0
Grep matches read, readFile, readFileSync, readdir, and every comment containing "read". LSP resolves the actual MetadataManager.read() calls — nothing else.
Supported languages: TypeScript, Python, Go, Rust, Java, C#
How it works: SpecWeave starts a language server alongside your agent session. Every "find references", "go to definition", and "show type" query goes through the LSP instead of grep — 198x faster with zero false positives.
specweave lsp refs src/core/metadata.ts read # Semantic references
specweave lsp def src/cli/commands/init.ts init # Go to definition
specweave lsp hover src/core/config.ts Config # Type informationCustomize any skill without forking.
# First time
You: "Generate a login form"
Claude: *creates form with useState*
You: "No, we always use React Hook Form + Zod"
# SpecWeave learns this → .specweave/skill-memories/frontend.md
# Next session — any agent, any skill
You: "Generate a signup form"
Claude: *automatically uses React Hook Form + Zod*| Traditional Tools | SpecWeave Skills |
|---|---|
| Obfuscated behavior | Transparent SKILL.md |
| Can't customize | Extend via skill-memories |
| Vendor lock-in | You control the logic |
| Suggestions only | Programmable reasoning |
Enable auto-learning:
/sw:reflect-on # Corrections become permanent knowledge
/sw:reflect-status # See what Claude has learnedSkills deep dive | Skill development guidelines
npm install -g specweave
cd your-project
specweave init .Then in Claude Code:
You: "Add dark mode to the app"
→ SpecWeave creates spec, plans architecture, builds it autonomously.
Node.js 20.12.0+ required (22 LTS recommended). Getting
SyntaxError? Upgrade instructions.
All commands activate automatically from natural language. Use directly for fine-grained control.
| Command | Purpose | Natural trigger |
|---|---|---|
/sw:increment "feature" |
Create spec + plan + tasks | "Build me X" |
/sw:auto |
Autonomous execution | "Go ahead and build it" |
/sw:do |
Execute one task at a time | "Do the next task" |
/sw:grill |
Code review before close | "Review the code" |
/sw:done |
Close with quality validation | "Ship it" |
/sw:progress-sync |
Push to GitHub / JIRA / ADO | "Sync progress" |
/sw:next |
Auto-close + suggest next | "What's next?" |
| Platform | What Syncs |
|---|---|
| GitHub | Issues, PRs, milestones — bidirectional |
| JIRA | Epics, stories, status |
| Azure DevOps | Work items, area paths |
When you close an increment, external tools update automatically.
| Capability | SpecWeave | BMAD Method | GitHub SpecKit |
|---|---|---|---|
| Parallel agent coordination | Increment-scoped isolation | No | No |
| Autonomous execution | Hours of unattended /sw:auto
|
No | No |
| Agent swarms (iTerm/tmux) | Visual parallel monitoring | No | No |
| Quality gates | Code Grill before every release | No | No |
| Living documentation | Auto-updated after every task | Manual | Manual |
| Self-improving AI | Learns from corrections | No | No |
| Enterprise compliance | SOC 2, HIPAA, FDA audit trails | No | No |
| External sync | GitHub / JIRA / ADO bidirectional | No | No |
| Brownfield support | Analyzer + migration patterns | No | No |
| LSP code intelligence | 198x faster, semantic accuracy | No | No |
| Specialized skills | 100+ (PM, QA, DevOps, ML...) | 21 agents | None |
| Spec/plan/tasks workflow | Yes | Yes | Yes |
| Agent-agnostic | Claude Code + OpenClaw + Copilot + Codex | Multi-IDE | Multi-IDE |
SpecWeave builds itself. Every feature, bug fix, and release is spec-driven.
Browse increments — see how SpecWeave develops SpecWeave.
spec-weave.com — guides, examples, and full reference.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for specweave
Similar Open Source Tools
specweave
SpecWeave is a spec-driven Skill Fabric for AI coding agents that allows programming AI in English. It provides first-class support for Claude Code and offers reusable logic for controlling AI behavior. With over 100 skills out of the box, SpecWeave eliminates the need to learn Claude Code docs and handles various aspects of feature development. The tool enables users to describe what they want, and SpecWeave autonomously executes tasks, including writing code, running tests, and syncing to GitHub/JIRA. It supports solo developers, agent teams working in parallel, and brownfield projects, offering file-based coordination, autonomous teams, and enterprise-ready features. SpecWeave also integrates LSP Code Intelligence for semantic understanding of codebases and allows for extensible skills without forking.
multi-agent-shogun
multi-agent-shogun is a system that runs multiple AI coding CLI instances simultaneously, orchestrating them like a feudal Japanese army. It supports Claude Code, OpenAI Codex, GitHub Copilot, and Kimi Code. The system allows you to command your AI army with zero coordination cost, enabling parallel execution, non-blocking workflow, cross-session memory, event-driven communication, and full transparency. It also features skills discovery, phone notifications, pane border task display, shout mode, and multi-CLI support.
vibe-remote
Vibe Remote is a tool that allows developers to code using AI agents through Slack or Discord, eliminating the need for a laptop or IDE. It provides a seamless experience for coding tasks, enabling users to interact with AI agents in real-time, delegate tasks, and monitor progress. The tool supports multiple coding agents, offers a setup wizard for easy installation, and ensures security by running locally on the user's machine. Vibe Remote enhances productivity by reducing context-switching and enabling parallel task execution within isolated workspaces.
Archon
Archon is an AI meta-agent designed to autonomously build, refine, and optimize other AI agents. It serves as a practical tool for developers and an educational framework showcasing the evolution of agentic systems. Through iterative development, Archon demonstrates the power of planning, feedback loops, and domain-specific knowledge in creating robust AI agents.
OpenOutreach
OpenOutreach is a self-hosted, open-source LinkedIn automation tool designed for B2B lead generation. It automates the entire outreach process in a stealthy, human-like way by discovering and enriching target profiles, ranking profiles using ML for smart prioritization, sending personalized connection requests, following up with custom messages after acceptance, and tracking everything in a built-in CRM with web UI. It offers features like undetectable behavior, fully customizable Python-based campaigns, local execution with CRM, easy deployment with Docker, and AI-ready templating for hyper-personalized messages.
tandem
Tandem is a local-first, privacy-focused AI workspace that runs entirely on your machine. It is inspired by early AI coworking research previews, open source, and provider-agnostic. Tandem offers privacy-first operation, provider agnosticism, zero trust model, true cross-platform support, open-source licensing, modern stack, and developer superpowers for everyone. It provides folder-wide intelligence, multi-step automation, visual change review, complete undo, zero telemetry, provider freedom, secure design, cross-platform support, visual permissions, full undo, long-term memory, skills system, document text extraction, workspace Python venv, rich themes, execution planning, auto-updates, multiple specialized agent modes, multi-agent orchestration, project management, and various artifacts and outputs.
llm4s
LLM4S provides a simple, robust, and scalable framework for building Large Language Models (LLM) applications in Scala. It aims to leverage Scala's type safety, functional programming, JVM ecosystem, concurrency, and performance advantages to create reliable and maintainable AI-powered applications. The framework supports multi-provider integration, execution environments, error handling, Model Context Protocol (MCP) support, agent frameworks, multimodal generation, and Retrieval-Augmented Generation (RAG) workflows. It also offers observability features like detailed trace logging, monitoring, and analytics for debugging and performance insights.
aiconfigurator
The `aiconfigurator` tool assists in finding a strong starting configuration for disaggregated serving in AI deployments. It helps optimize throughput at a given latency by evaluating thousands of configurations based on model, GPU count, and GPU type. The tool models LLM inference using collected data for a target machine and framework, running via CLI and web app. It generates configuration files for deployment with Dynamo, offering features like customized configuration, all-in-one automation, and tuning with advanced features. The tool estimates performance by breaking down LLM inference into operations, collecting operation execution times, and searching for strong configurations. Supported features include models like GPT and operations like attention, KV cache, GEMM, AllReduce, embedding, P2P, element-wise, MoE, MLA BMM, TRTLLM versions, and parallel modes like tensor-parallel and pipeline-parallel.
kiss_ai
KISS AI is a lightweight and powerful multi-agent evolutionary framework that simplifies building AI agents. It uses native function calling for efficiency and accuracy, making building AI agents as straightforward as possible. The framework includes features like multi-agent orchestration, agent evolution and optimization, relentless coding agent for long-running tasks, output formatting, trajectory saving and visualization, GEPA for prompt optimization, KISSEvolve for algorithm discovery, self-evolving multi-agent, Docker integration, multiprocessing support, and support for various models from OpenAI, Anthropic, Gemini, Together AI, and OpenRouter.
nono
nono is a secure, kernel-enforced capability shell for running AI agents and any POSIX style process. It leverages OS security primitives to create an environment where unauthorized operations are structurally impossible. It provides protections against destructive commands and securely stores API keys, tokens, and secrets. The tool is agent-agnostic, works with any AI agent or process, and blocks dangerous commands by default. It follows a capability-based security model with defense-in-depth, ensuring secure execution of commands and protecting sensitive data.
rho
Rho is an AI agent that runs on macOS, Linux, and Android, staying active, remembering past interactions, and checking in autonomously. It operates without cloud storage, allowing users to retain ownership of their data. Users can bring their own LLM provider and have full control over the agent's functionalities. Rho is built on the pi coding agent framework, offering features like persistent memory, scheduled tasks, and real email capabilities. The agent can be customized through checklists, scheduled triggers, and personalized voice and identity settings. Skills and extensions enhance the agent's capabilities, providing tools for notifications, clipboard management, text-to-speech, and more. Users can interact with Rho through commands and scripts, enabling tasks like checking status, triggering actions, and managing preferences.
WebAI-to-API
This project implements a web API that offers a unified interface to Google Gemini and Claude 3. It provides a self-hosted, lightweight, and scalable solution for accessing these AI models through a streaming API. The API supports both Claude and Gemini models, allowing users to interact with them in real-time. The project includes a user-friendly web UI for configuration and documentation, making it easy to get started and explore the capabilities of the API.
OpenSpec
OpenSpec is a tool for spec-driven development, aligning humans and AI coding assistants to agree on what to build before any code is written. It adds a lightweight specification workflow that ensures deterministic, reviewable outputs without the need for API keys. With OpenSpec, stakeholders can draft change proposals, review and align with AI assistants, implement tasks based on agreed specs, and archive completed changes for merging back into the source-of-truth specs. It works seamlessly with existing AI tools, offering shared visibility into proposed, active, or archived work.
openakita
OpenAkita is a self-evolving AI Agent framework that autonomously learns new skills, performs daily self-checks and repairs, accumulates experience from task execution, and persists until the task is done. It auto-generates skills, installs dependencies, learns from mistakes, and remembers preferences. The framework is standards-based, multi-platform, and provides a Setup Center GUI for intuitive installation and configuration. It features self-learning and evolution mechanisms, a Ralph Wiggum Mode for persistent execution, multi-LLM endpoints, multi-platform IM support, desktop automation, multi-agent architecture, scheduled tasks, identity and memory management, a tool system, and a guided wizard for setup.
multi-agent-ralph-loop
Multi-agent RALPH (Reinforcement Learning with Probabilistic Hierarchies) Loop is a framework for multi-agent reinforcement learning research. It provides a flexible and extensible platform for developing and testing multi-agent reinforcement learning algorithms. The framework supports various environments, including grid-world environments, and allows users to easily define custom environments. Multi-agent RALPH Loop is designed to facilitate research in the field of multi-agent reinforcement learning by providing a set of tools and utilities for experimenting with different algorithms and scenarios.
For similar tasks
specweave
SpecWeave is a spec-driven Skill Fabric for AI coding agents that allows programming AI in English. It provides first-class support for Claude Code and offers reusable logic for controlling AI behavior. With over 100 skills out of the box, SpecWeave eliminates the need to learn Claude Code docs and handles various aspects of feature development. The tool enables users to describe what they want, and SpecWeave autonomously executes tasks, including writing code, running tests, and syncing to GitHub/JIRA. It supports solo developers, agent teams working in parallel, and brownfield projects, offering file-based coordination, autonomous teams, and enterprise-ready features. SpecWeave also integrates LSP Code Intelligence for semantic understanding of codebases and allows for extensible skills without forking.
For similar jobs
DotRecast
DotRecast is a C# port of Recast & Detour, a navigation library used in many AAA and indie games and engines. It provides automatic navmesh generation, fast turnaround times, detailed customization options, and is dependency-free. Recast Navigation is divided into multiple modules, each contained in its own folder: - DotRecast.Core: Core utils - DotRecast.Recast: Navmesh generation - DotRecast.Detour: Runtime loading of navmesh data, pathfinding, navmesh queries - DotRecast.Detour.TileCache: Navmesh streaming. Useful for large levels and open-world games - DotRecast.Detour.Crowd: Agent movement, collision avoidance, and crowd simulation - DotRecast.Detour.Dynamic: Robust support for dynamic nav meshes combining pre-built voxels with dynamic objects which can be freely added and removed - DotRecast.Detour.Extras: Simple tool to import navmeshes created with A* Pathfinding Project - DotRecast.Recast.Toolset: All modules - DotRecast.Recast.Demo: Standalone, comprehensive demo app showcasing all aspects of Recast & Detour's functionality - Tests: Unit tests Recast constructs a navmesh through a multi-step mesh rasterization process: 1. First Recast rasterizes the input triangle meshes into voxels. 2. Voxels in areas where agents would not be able to move are filtered and removed. 3. The walkable areas described by the voxel grid are then divided into sets of polygonal regions. 4. The navigation polygons are generated by re-triangulating the generated polygonal regions into a navmesh. You can use Recast to build a single navmesh, or a tiled navmesh. Single meshes are suitable for many simple, static cases and are easy to work with. Tiled navmeshes are more complex to work with but better support larger, more dynamic environments. Tiled meshes enable advanced Detour features like re-baking, hierarchical path-planning, and navmesh data-streaming.
bots
The 'bots' repository is a collection of guides, tools, and example bots for programming bots to play video games. It provides resources on running bots live, installing the BotLab client, debugging bots, testing bots in simulated environments, and more. The repository also includes example bots for games like EVE Online, Tribal Wars 2, and Elvenar. Users can learn about developing bots for specific games, syntax of the Elm programming language, and tools for memory reading development. Additionally, there are guides on bot programming, contributing to BotLab, and exploring Elm syntax and core library.
Half-Life-Resurgence
Half-Life-Resurgence is a recreation and expansion project that brings NPCs, entities, and weapons from the Half-Life series into Garry's Mod. The goal is to faithfully recreate original content while also introducing new features and custom content envisioned by the community. Users can expect a wide range of NPCs with new abilities, AI behaviors, and weapons, as well as support for playing as any character and replacing NPCs in Half-Life 1 & 2 campaigns.
SwordCoastStratagems
Sword Coast Stratagems (SCS) is a mod that enhances Baldur's Gate games by adding over 130 optional components focused on improving monster AI, encounter difficulties, cosmetic enhancements, and ease-of-use tweaks. This repository serves as an archive for the project, with updates pushed only when new releases are made. It is not a collaborative project, and bug reports or suggestions should be made at the Gibberlings 3 forums. The mod is designed for offline workflow and should be downloaded from official releases.
LambsDanger
LAMBS Danger FSM is an open-source mod developed for Arma3, aimed at enhancing the AI behavior by integrating buildings into the tactical landscape, creating distinct AI states, and ensuring seamless compatibility with vanilla, ACE3, and modded assets. Originally created for the Norwegian gaming community, it is now available on Steam Workshop and GitHub for wider use. Users are allowed to customize and redistribute the mod according to their requirements. The project is licensed under the GNU General Public License (GPLv2) with additional amendments.
beehave
Beehave is a powerful addon for Godot Engine that enables users to create robust AI systems using behavior trees. It simplifies the design of complex NPC behaviors, challenging boss battles, and other advanced setups. Beehave allows for the creation of highly adaptive AI that responds to changes in the game world and overcomes unexpected obstacles, catering to both beginners and experienced developers. The tool is currently in development for version 3.0.
thinker
Thinker is an AI improvement mod for Alpha Centauri: Alien Crossfire that enhances single player challenge and gameplay with features like improved production/movement AI, visual changes on map rendering, more config options, resolution settings, and automation features. It includes Scient's patches and requires the GOG version of Alpha Centauri with the official Alien Crossfire patch version 2.0 installed. The mod provides additional DLL features developed in C++ for a richer gaming experience.
MobChip
MobChip is an all-in-one Entity AI and Bosses Library for Minecraft 1.13 and above. It simplifies the implementation of Minecraft's native entity AI into plugins, offering documentation, API usage, and utilities for ease of use. The library is flexible, using Reflection and Abstraction for modern functionality on older versions, and ensuring compatibility across multiple Minecraft versions. MobChip is open source, providing features like Bosses Library, Pathfinder Goals, Behaviors, Villager Gossip, Ender Dragon Phases, and more.
