speckit-agent-skills

Name: speckit-agent-skills
Author: dceoy

by dceoy

Verified

Agent skills for Spec Kit

132stars

28forks

Shell

Added 6/13/2026

Installation

# Add to your Claude Code skills
git clone https://github.com/dceoy/speckit-agent-skills

Getting Started

Guides for using ai agents skills like speckit-agent-skills.

Caveman: Cut Claude Token Use by 65%
How agent-side prompt compression works, when to use it, and when not to.
What is an AI Skills Marketplace?
Definitions, how marketplaces work, and how to choose between them in 2026.
Getting Started with AI Skills

Security ReportVerified

Last scanned: 6/13/2026

{
  "issues": [],
  "status": "PASSED",
  "scannedAt": "2026-06-13T07:46:47.424Z",
  "npmAuditRan": true,
  "pipAuditRan": true,
  "promptInjectionRan": true
}

Compare with similar skills

See how speckit-agent-skills compares with popular alternatives.

speckit-agent-skills vs ecc

See comparison

speckit-agent-skills vs everything claude code

See comparison

speckit-agent-skills vs hermes agent

README.md

Frequently Asked Questions

What is speckit-agent-skills?

speckit-agent-skills is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by dceoy. Agent skills for Spec Kit. It has 132 GitHub stars.

Is speckit-agent-skills safe to use?

Yes. speckit-agent-skills passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.

How do I install speckit-agent-skills?

Clone the repository with "git clone https://github.com/dceoy/speckit-agent-skills" and add it to your Claude Code skills directory (see the Installation section above).

What programming language is speckit-agent-skills written in?

speckit-agent-skills is primarily written in Shell. It is open-source under dceoy on GitHub, so you can review or fork the full source.

Are there alternatives to speckit-agent-skills?

Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh speckit-agent-skills against similar tools.

Agentic AI for Beginners

Build your first AI agent from scratch - tool use, ReAct pattern, memory, deployment

41 minBeginner

Comments (0)

to leave a comment.

No comments yet. Be the first to share your thoughts!

Related Skills

ECC

by affaan-m

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

257,289

open-skills TokenBar

⚠️ Third-Party Software Notice

This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM is an informational directory and does not control or maintain the underlying repository.

Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.

Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.

Read the Terms of Service

speckit-agent-skills

Agent skills and generated runtime entry points for Spec Kit.

Overview

This repository tracks the current Spec Kit output together with a small set of repository-specific skills.

Shared Agent Skills - skills/ contains the shared speckit-* skills plus repository-specific skills. Claude Code uses them through .claude/skills, while Codex CLI uses them through .agents/skills.
Cursor Agent - Spec Kit-generated skills live in .cursor/skills/.
GitHub Copilot CLI - Spec Kit-generated agents and prompt wrappers live in .github/agents/ and .github/prompts/.
OpenCode - Spec Kit-generated commands live in .opencode/commands/.
Gemini CLI - .gemini/commands/ remains checked in, but Gemini is not part of the current CI regeneration set.
Spec Kit infrastructure - .specify/ contains integration state, manifests, scripts, and templates used by the generated skills and commands.

The tracked Spec Kit version is recorded in VERSION.md. CI checks the latest Spec Kit release and regenerates outputs only when that version changes.

Current integration model

The repository CI currently runs specify init --integration for:

codex
agy
cursor-agent
copilot
opencode
claude

The generated files are therefore not all stored in the same layout:

Runtime / integration	Repository path	Role
Agent Skills (`agy`)	`skills/`	Shared Spec Kit skills
Claude Code	`.claude/skills -> ../skills`	Shared skills exposed to Claude Code
Codex CLI	`.agents/skills -> ../skills`	Shared skills exposed to Codex
Cursor Agent	`.cursor/skills/`	Cursor-specific generated skill copies
GitHub Copilot CLI	`.github/agents/`, `.github/prompts/`	Generated agents and prompt wrappers
OpenCode	`.opencode/commands/`	Generated commands
Gemini CLI	`.gemini/commands/`	Checked-in commands; not regenerated by the current CI configuration

Legacy layouts such as .claude/commands/, .codex/prompts/, and .opencode/command/ are intentionally not maintained.

Quickstart

Clone this repository.

git clone https://github.com/dceoy/speckit-agent-skills.git
cd speckit-agent-skills

Install Spec Kit.
Initialize a target project with the Spec Kit integration appropriate for your agent.
```
specify init --here --integration <integration>
```
If the target runtime consumes Agent Skills directly, copy the required skills from skills/ into that project's skills directory when needed.
```
cp -a skills/* /path/to/project/skills/
```
Invoke the relevant speckit-* skill or runtime command from your agent.

Spec Kit workflow

The main Spec-Driven Development flow in this repository is:

Constitution - Define project principles.
Specify - Capture requirements for new work.
- Or Baseline - Derive a specification from an existing codebase.
Clarify (optional) - Resolve material ambiguities.
Plan - Produce the implementation strategy.
Tasks - Generate ordered work items.
Analyze (optional) - Check consistency across the specification, plan, and tasks.
Converge (optional) - Compare an existing implementation with the spec/plan/tasks and append remaining work to tasks.md.
Implement - Execute the tasks.

Additional utilities include Checklist for requirements-quality checks and Tasks to Issues for converting generated tasks into GitHub issues.

Visual workflow

flowchart TD
  C0["speckit-constitution"] --> C1["speckit-specify"]
  C0 --> B["speckit-baseline"]
  C1 --> C2["speckit-plan"]
  B --> C2
  C2 --> C3["speckit-tasks"]
  C3 --> C4["speckit-implement"]

  C1 -.-> O1["speckit-clarify"]
  B -.-> O1
  O1 -.-> C2

  C3 -.-> O2["speckit-analyze"]
  O2 -.-> C4

  C3 -.-> O3["speckit-converge"]
  O3 -.-> C4

  C3 -.-> O4["speckit-taskstoissues"]

  C1 -.-> O5["speckit-checklist"]
  C2 -.-> O5
  C3 -.-> O5

Skills

Spec Kit skills

The current shared speckit-* set includes:

speckit-analyze
speckit-baseline
speckit-checklist
speckit-clarify
speckit-constitution
speckit-converge
speckit-implement
speckit-plan
speckit-specify
speckit-tasks
speckit-taskstoissues

Most Spec Kit-managed skills are tracked by the manifests in .specify/integrations/. speckit-baseline is a repository-specific skill for deriving specifications from existing code.

Utility skills

claude-command-converter - Repository-specific utility for converting Claude command content into Agent Skill format.

Structure

.
├── skills/                      # Shared and repository-specific Agent Skills
├── .agents/
│   └── skills -> ../skills      # Codex CLI access to shared skills
├── .claude/
│   └── skills -> ../skills      # Claude Code access to shared skills
├── .cursor/
│   └── skills/                  # Cursor Agent generated skills
├── .gemini/
│   └── commands/                # Checked-in Gemini commands
├── .github/
│   ├── agents/                  # GitHub Copilot generated agents
│   ├── prompts/                 # GitHub Copilot prompt wrappers
│   └── workflows/               # CI and Spec Kit regeneration workflows
├── .opencode/
│   └── commands/                # OpenCode generated commands
├── .specify/
│   ├── integrations/            # Integration manifests
│   ├── scripts/bash/            # Spec Kit helper scripts
│   ├── templates/               # Spec Kit templates
│   ├── init-options.json        # Last initialization options
│   └── integration.json         # Current integration state
├── .vscode/
│   └── settings.json            # Workspace settings
└── VERSION.md                   # Tracked Spec Kit version

Regeneration

.github/workflows/ci.yml calls .github/workflows/speckit-init.yml. The workflow:

resolves the latest Spec Kit release,
records specify --version in VERSION.md,
skips regeneration when VERSION.md is unchanged,
runs specify init --force --here --ignore-agent-tools --script sh --integration for the configured integrations,
formats generated Markdown and JSON, and
commits updated Spec Kit outputs when the tracked version changes.

Treat manifest-managed runtime files as generated output. Prefer changing the integration configuration or repository-specific skills instead of manually maintaining generated copies.

Prerequisites

Install and authenticate only the runtime tools you intend to use, plus Spec Kit itself.

Claude Code - Uses .claude/skills.
OpenAI Codex CLI - Uses .agents/skills.
Cursor Agent - Uses .cursor/skills/.
GitHub Copilot CLI - Uses .github/agents/ and .github/prompts/.
OpenCode - Uses .opencode/commands/.
Gemini CLI - Can use the checked-in .gemini/commands/, but those files are outside the current regeneration set.
Spec Kit - Install from github.com/github/spec-kit.

Usage notes

Skills do not always auto-run; use the runtime's skill invocation flow or request the skill explicitly.
If a skill fails, inspect its SKILL.md and verify the required Spec Kit project structure and prerequisites.
Run Spec Kit helper scripts from the repository root and prefer their structured output modes such as --json when available.
Do not restore legacy runtime layouts unless a currently supported Spec Kit integration starts generating them again.

License

See LICENSE for details.