ai-agents

Superpowers teaches Claude a disciplined, hands-on software workflow so it can behave like a developer on your team. It reads code snippets or repo context you give it, generates concrete unit and integration test cases, maps tests to implementation points, and outlines small TDD cycles: write a failing test, implement minimal code, run assertions, refactor. It frames commits and small diffs, and it drafts the commit message and PR description that match the test-driven changes. The plugin also walks through systematic debugging: it reproduces failure steps from logs or stack traces you paste, isolates likely root causes, ranks hypotheses, and suggests targeted fixes and smaller follow-up tests. It runs Socratic brainstorming sessions by asking constraining questions, proposing alternatives, and scoring trade-offs. For review-heavy flows it spins up subagent-driven reviews that check style, API contracts, and edge cases, then aggregates reviewer comments into a prioritized todo list. You can extend the framework by defining custom skills that read files, run a checklist, or produce a standardized review template. Use Superpowers when you want to go from failing test to merged PR without juggling docs, chat threads, or another review tool. For example, paste failing CI logs from a microservice, have Claude generate the failing test, propose a minimal patch, and collect subagent review comments — you avoid switching to a separate whiteboard session or manual inbox review and get a clear path to a green build. See the implementation on GitHub: https://github.com/obra/superpowers

CLAUDE.md Management reads your project's CLAUDE.md, audits entries for relevance and duplicates, and marks stale or conflicting lines so you can focus on the parts that matter. It parses recent session logs and maps facts, decisions, and follow-ups back to the file format you already use. It also generates a short changelog of suggested edits and creates draft paragraphs you can accept or modify. It captures lessons from each interactive session by extracting concrete facts, commands run, file paths touched, and unresolved questions, then proposes where to append or replace content in CLAUDE.md. The tool checks for contradictions between memory entries and recent session evidence, highlights risky assumptions, and can create a compact summary of what changed across sessions. Use it when you finish a debugging sprint: the plugin pulls your session notes, summarizes the bug root cause and the commands that fixed it, updates CLAUDE.md with a clear "how we fixed it" section, and adds follow-ups to your task list. That saves you switching to a separate note app and prevents Claude from asking the same setup questions in the next code review.

Skill Creator helps you build Claude Code skills step by step. It presents a guided Create mode where you write skill code, define inputs and outputs, and attach example prompts. The tool reads your project files, scaffolds handlers, and generates a local dev environment so you can run the skill and inspect logs without manual setup. Eval mode runs test suites against your skill: it sends batches of prompts, records responses, and calculates concrete metrics like accuracy, response time, and failure rate. Improve mode applies targeted edits — you can generate new test cases, tweak prompt templates, or swap handlers, then re-run the same tests to compare results. The interface shows diffed outputs and highlights regressions. Benchmark mode runs A/B comparisons across versions and records historical performance. You can export CSVs of results, map metrics to releases, and set pass/fail gates for CI. The tool also packages a production-ready skill bundle you can publish or deploy. For example, a support team can use Skill Creator to build an FAQ skill, run dozens of real tickets through Eval, iterate prompts in Improve, and run a Benchmark to confirm the new version reduces incorrect answers — all without switching between editors, test runners, and spreadsheets.

Feature Dev guides a feature from idea to shipped code with a structured seven-step workflow and small focused agents for discovery, design decisions, implementation, and final review. It reads your feature brief or ticket, maps stakeholders and constraints, and generates a clear list of acceptance criteria and edge cases to validate against. During design it creates concrete artifacts: API sketches, data model diagrams, sequence steps, and a prioritized task breakdown. It generates user stories, example requests and responses, and a checklist of UX and accessibility points. For implementation it writes test templates, suggests coding tasks, and creates a ready-to-open pull request description. For review it runs a review agent that checks the checklist, compares changes to the acceptance criteria, and produces reviewer notes and a list of follow-up tasks. It can open issues, add labels, post PR comments, and produce a final release note draft so reviewers know what to verify. Imagine turning a vague product note into a ticket, design sketch, test plan, PR description, and release notes without leaving your editor or project board — you avoid hopping between docs, issue trackers, and review threads and cut handoffs and context switching during a sprint.

Claude Code Setup reads your repository, maps file types, and detects frameworks, package manifests, Dockerfiles, CI pipelines and common directory layouts. It runs static checks and dependency scans to figure out where automations can attach: server hooks, local subagents, skill entry points, MCP server roles, and slash command targets. It suggests specific code locations and generates concrete config snippets you can paste or commit: YAML for MCP servers, manifest files for skills, hook definitions, subagent templates and example slash-command handlers. It also lists npm/pip install commands, example env variables, and minimal runtime requirements. The tool shows change lists and patch-ready files so you can apply recommended files or copy them into your repo. It flags risky changes, points to relevant docs and gives sample tests you can run to verify the automation hooks. In a real-world scenario, a backend engineer can run it against a microservice repo, get ready-to-commit MCP and subagent files and a test plan, and enable CLAUDE CODE automations without juggling multiple docs, chat threads, or editor tabs — saving hours and avoiding context switching. GitHub: https://github.com/anthropics/claude-code

Ralph Loop runs Claude on a loop that reads its previous output, test results, and git history, then makes targeted edits on the next pass. It captures file diffs, commit messages, and failing tests so each iteration starts from the exact state of the last run. The plugin watches the repo, records state, and feeds concrete failure information back into the prompt so changes become focused and incremental instead of redoing work from scratch. On each cycle Ralph Loop runs the same test suite, parses failures, and applies edits or new commits. You can configure iteration limits, stop conditions, and which files to protect. The plugin stores every intermediate commit and exposes the chain of changes, so you can review why a particular fix was attempted and revert or cherry-pick any step. Ralph Loop connects to your local or remote git host, pushes commits, and preserves branch history. It annotates commits with the test output that triggered them and provides a clear loop log. You keep full control: approve or reject commits, force a different strategy, or inject a human note between passes. In practice this saves time when fixing flaky tests or iterating on a feature: instead of copying failures into a new tool and re-running builds manually, Ralph Loop keeps the context, runs tests, and updates code until tests pass or you stop it — no tool switching or lost debug state.

Remember records and organizes your Claude conversations across sessions. It reads your chat history and the files you touched, extracts key facts and decisions, and compresses them into tiered logs: short daily Haikus, medium summaries, and long-form context you can query later. It tags entries by project, file path, and topic so Claude can pull exactly the context relevant to the current task without re-reading everything.It runs automatically in the background with no setup: every time you work it appends new memories, updates summaries, and prunes redundant entries. Daily Haikus are short, human-readable snapshots that highlight what changed each day. Longer logs keep timelines, open questions, and code snippets so Claude can answer where you left off, what you decided, and why.Remember exposes commands to list recent memories, jump to a specific file’s timeline, and forget sensitive items. It compresses older content to save space and keeps recent context verbatim so debugging or design discussions remain actionable. You can query past decisions, search by tag, or ask for the chain of changes on a file.Imagine returning after a three-day break: instead of opening multiple repos and notes, Claude reads the project Haiku, pulls the file timeline, and reminds you which bug you were reproducing and which test you planned to write — saving you from switching to your task tracker or digging through commit logs.

Hookify connects your Claude Code projects with GitHub webhooks and local endpoints so you can route events into model-driven workflows. It reads webhook payloads, validates signatures, maps event types to handlers, and forwards JSON to configured Claude Code routes. You can add retry rules, filter by branch or file paths, and log incoming events to a local file or remote sink. Installation instructions and source are on GitHub: https://github.com/anthropics/claude-code. The tool runs as a small HTTP service, watches a config file for changes, and exposes a simple UI endpoint that lists recent events and delivery status. It supports HMAC secrets, custom headers, and TLS for public endpoints. Operational features include a test event sender, delivery retries with backoff, and a plugin script hook that transforms payloads before forwarding. The service records request/response pairs, checks for common webhook errors, and can mute noisy event types so your Claude Code routes only receive relevant data. Use Hookify when you want incoming GitHub activity to trigger model flows without opening cloud portals. For example, it receives PR comments locally, filters for “/rerun” commands, transforms the payload, and sends a compact request to a Claude Code route — saving time and avoiding manual copy-paste between GitHub and your development tools.

Plugin Developer Toolkit bundles seven focused skills that show how Claude Code plugins are built from the ground up. It reads and explains hook lifecycle, maps plugin manifest structure, shows MCP server registration and auth flows, and demonstrates how slash commands and agent entry points work. The repo includes over a dozen runnable examples so you can open code, run it, and see requests and responses in context.You get six validation scripts that check manifests, type schemas, and security headers, plus more than 21,000 words of documentation that walks through deployment patterns, error handling, and testing strategies. The package sends ready-to-run dev server configs, example webhooks, and test payloads so you can iterate locally. It also shows how to author new skills and wire them into agent and slash-command flows.Imagine building a support bot that needs slash commands, background hooks, and an MCP server for auth: the Toolkit provides examples, validation checks, and deploy configs so you can code, test, and deploy without switching between scattered guides and repos. The GitHub repo at https://github.com/anthropics/claude-code stores all examples and scripts for cloning and immediate use.

Turn Claude into a hands-on coding mentor that pauses at concrete decision points and asks you to act. This plugin watches the code generation flow, identifies spots like error handling, input validation, loop logic, or API wiring, and inserts prompts asking you to write 5–10 lines of code or choose between two approaches. It records your answers and continues only after you confirm or paste your snippet. The tool checks your snippet for syntax, runs quick static checks, and shows inline diffs so you can compare the model’s suggestion with your code. It can force you to pick architecture alternatives, name variables, or write unit test stubs. It keeps the session interactive by tracking which concepts you’ve practiced and which ones the model handled. You get a session log that maps each pause to the learning objective, the code you wrote, and the model’s alternative. Use it to replay steps, export exercises, or generate follow-up quizzes. It supports CLI-style tasks, web handlers, and small refactors. In a real project, the plugin saves time during code reviews: instead of switching to an editor to try a fix, you write and validate the snippet right inside Claude Code, then continue the guided session without toggling tools or losing context.

Agent SDK Dev gives you the repo, CLI commands, and example code you need to start building Claude-powered agents in minutes. It reads your language choice (TypeScript or Python), generates a project layout, wires in auth and API clients, and includes sample agent flows so you can run a working example without hunting for configuration details. The kit provides scaffolding for handlers, tools, and memory layers, plus ready-made hooks for logging, telemetry, and error handling. It adds linting rules, unit test stubs, and CI workflow templates so you can run code checks and tests from day one. The included examples show how to send messages, call tools, persist conversation state, and validate inputs. Use the CLI to run a local dev server, run tests, or generate new agent modules. The code is organized so you can swap components, add custom tools, or extend memory implementations without rewriting boilerplate. The repo maps network calls, environment variables, and deployment-ready Dockerfiles so you can build and package agents for staging or production. In a real sprint, you can scaffold a new agent, wire an external API, and run unit tests all from the same workspace. That saves time and prevents flipping between multiple templates, docs, and one-off scripts when you just need to iterate on behavior and get feedback fast.

This plugin restores the explanatory tone developers relied on: Claude reads your code and comments, explains the reasoning behind each implementation decision, and highlights codebase patterns worth knowing. It annotates suggested changes with short rationales, points out trade-offs, and flags assumptions the assistant made when proposing edits. Use it when you want follow-up context alongside diffs or example implementations. The extension generates compact learning notes: it identifies repeating abstractions, maps where patterns appear, and calls out surprising dependencies or API contracts. It ties suggestions to code paths, explains why one approach is safer or faster in your repository, and shows where you may need to add tests or refactor to avoid technical debt. It also summarizes the impact of changes on performance, readability, and coupling. When you ask for code, responses include a step-by-step explanation of the decision chain, not just the final patch. The plugin marks optional changes versus required fixes, lists follow-up tasks, and provides short code examples illustrating the alternative approaches it described. Real-world example: reviewing a pull request that refactors authentication — instead of jumping to docs or chat, the assistant explains why a token cache was chosen, where to invalidate it, and which existing modules will break; that saves switching to a browser to hunt for context and reduces back-and-forth in code review.

Scaffolds and validates AI agents using the Atomic Agents framework — specialized tooling and built-in best practice enforcement throughout the build process.Building AI agents doesn't have to be complicated. Atomic Agents gives you a complete workflow for creating intelligent agents from the ground up, with specialized helpers that guide you through schema design, planning out your architecture, reviewing code, and developing tools. It walks you through each step with clear guidance, teaches you skills as you need them, and keeps you on track with best practice validation so you actually build something solid.