Help us improve
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
By iusztinpaul
Orchestrate an autonomous agent team for Python/TypeScript/Go monorepos that handles the full development cycle: from spec grooming and task planning to implementation, testing, code review, PR management, CI/CD fix, and architecture refactoring, with safety guards and progressive-disclosure specs.
npx claudepluginhub iusztinpaul/squid --plugin squidMonitors CI/CD after `git push`. If the pipeline fails, identifies the related task from commit messages, reopens it, fixes the code locally, runs tests, pushes the fix with `Refs
Reads the git diff after a feature is pushed. Tags every finding as Blocker or Nit. Produces ONE rollup task containing all findings. Does NOT read CI, does NOT comment on the PR, does NOT merge. Use after the SWE has pushed the feature branch and before the orchestrator hands the PR back to the human for squash-merge.
Grooms raw tasks into agent-ready specs (acceptance criteria + BDD scenarios) AND does final user-perspective acceptance review after the Tester passes. Use whenever a task needs to be turned into something the SWE can build, or whenever a task needs the final "is this actually right for users?" review before commit.
Implements a single groomed task assigned by the orchestrator. Writes code and tests locally. Does NOT commit until the Tester has reviewed and approved. Use when a task is groomed and ready for implementation, or when the Tester has returned feedback that needs to be addressed.
Reviews the software-engineer's uncommitted work against the spec and acceptance criteria. Runs the full test suite, verifies every acceptance criterion with evidence, and gives PASS or FAIL. Use after the SWE reports an implementation is done, or after the SWE applies fixes for previously-flagged issues.
Periodic architectural sweep of a codebase — reads existing ADRs to avoid re-litigating settled decisions, maps the current module/dependency graph and layering, surfaces 5–10 architectural smells with severity, and emits each finding as a refactor proposal that `/refactor` can consume directly. Trigger when the user says "/architecture-review", "audit the architecture", "what's wrong with this codebase", asks before a major version bump, or when long-horizon tech debt feels untracked.
Create or update a GitHub pull request for the current branch. Use this skill whenever the user says "create PR", "open PR", "update PR", "push and PR", "/create-pr", or when the PR workflow step is reached in the development workflow. Handles both first-time PR creation and updating existing PRs with new changes.
Run a single task through the inner SWE↔Tester loop with the human supervising in real time. SWE implements, Tester verifies (including the e2e adversarial pass), you review the diff and commit. No PM grooming, no PM acceptance, no PR Reviewer, no On-Call. Trigger when the user wants to ship one task under active supervision, or says "/day".
Install Claude Code PreToolUse hooks that block destructive git/shell commands before they execute — force-push to protected branches, `git reset --hard` of unstaged work, `git push --no-verify`, and `rm -rf` paths that escape the worktree. Smart-merges into the project's `.claude/settings.json` and writes one guardian script. Trigger when the user says "/git-guardrails", asks to harden Claude Code against destructive git commands, or is about to run `/night` unattended for the first time.
Adversarially interview a feature spec before plan approval — surface every unresolved decision (auth model, error semantics, persistence, idempotency, observability, rollout, scope edges), draft codebase-grounded answers where possible, and ask the human only the questions that genuinely need their input. Output is a decision-resolved spec ready for PM grooming. Trigger when the user says "/grill-me", asks "is this spec ready", "poke holes in this", "interview me on this plan", or before invoking `/night` on a vague feature description.
Uses power tools
Uses Bash, Write, or Edit tools
Share bugs, ideas, or general feedback.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Persona-driven AI development team: orchestrator, team agents, review agents, skills, slash commands, and advisory hooks for Claude Code
Virtual development team: TDD, debugging, code review, backlog management, and proven workflow patterns
PROJECT.md-first autonomous development with hybrid auto-fix documentation. 8-agent pipeline, auto-orchestration, docs auto-update on commit (true vibe coding). Knowledge base system with 90% faster repeat research. Strict mode enforces SDLC best practices automatically. Works for ANY Python/JavaScript/TypeScript/Go project.
Orchestrate multi-agent teams for parallel code review, hypothesis-driven debugging, and coordinated feature development using Claude Code's Agent Teams
AI-First SDLC — zero-debt development with validators, enforcement, and workflows
AI-powered agents for specialized development tasks
Claude Code writes code fast. It's worse at writing the code your team would actually ship — the kind that follows your conventions, has tests you trust, and survives review.
Squid is a Claude Code plugin that turns a feature spec into a reviewed PR using a 5-agent pipeline — PM → SWE → Tester → PR Reviewer → On-Call — with exactly two human gates: plan approval and final merge.
No file templates. No render step. Markdown specs + agent contracts only; every file in your project gets written by an agent that reads those specs and follows them.
Run /night <feature-spec> and Squid drives this pipeline end-to-end:
feature spec
│
▼
┌─────────────┐ ┌─────────────────────┐ ┌────────────────────┐
│ PM grooms │────▶│ HUMAN approves │────▶│ SWE ↔ Tester loop │
│ Tasks Plan │ │ Tasks Plan (1/2) │ │ (per task) │
└─────────────┘ └─────────────────────┘ └────────────────────┘
│
▼
┌─────────────┐ ┌─────────────────────┐ ┌────────────────────┐
│ HUMAN │◀────│ PR Reviewer ‖ │◀────│ PM accepts + push │
│ merges PR │ │ On-Call (CI) │ │ │
│ (2/2) │ │ (run in parallel) │ │ │
└─────────────┘ └─────────────────────┘ └────────────────────┘
Branch + worktree, grooming, the per-task implement/verify loop, push, parallel CI + diff review, squash — all automated. You only show up for the two gates.
For active iteration on a single task, use /day <task> instead — same SWE ↔ Tester loop, no PM grooming, no PR pipeline. Use /scaffold first if you're starting from an empty directory; it interviews you about the stack, picks the right specs, and writes a tailored CLAUDE.md plus a folder skeleton (no application source).
If you want to learn how to build agentic coding frameworks such as Squid from scratch, consider joining 40k+ engineers by subscribing to the Decoding AI Magazine.

/plugin marketplace add iusztinpaul/squid
/plugin install squid@squid
That's it. Open any repo in Claude Code; the agents and skills appear in /agents and /help. Run /plugin marketplace update squid later to pull fresh changes.
Commit this into the target repo's .claude/settings.json:
{
"extraKnownMarketplaces": {
"squid": {
"source": {
"source": "github",
"repo": "iusztinpaul/squid"
}
}
},
"enabledPlugins": {
"squid@squid": true
}
}
When a teammate (or future-you on a fresh machine) opens that repo and trusts the folder, Claude Code prompts them to add the marketplace and install in one step. enabledPlugins alone isn't enough — extraKnownMarketplaces is what tells Claude Code where squid@squid resolves to.
claude --plugin-dir /path/to/squid
Launches Claude Code with the plugin loaded for the session. No marketplace, no install, no cache. Re-run after edits. This is the only path that exercises your local working tree directly on Claude Code v2.1+.
/plugin marketplace add /path/to/squidreads the localmarketplace.jsonbut the plugin'ssourcepoints at GitHub — so the install still fetches fromiusztinpaul/squid, not your working tree.