By zakattack9
Spec workflow by Zak Sakata: write-spec is the workflow entrypoint that turns a bare idea into a spec — eliciting and distilling requirements (full rigor) before drafting concise, scannable feature specs at a requested rigor (light/standard a code-free, implementation-agnostic WHAT to full deep spec that may pin implementation) that open with a flat, id'd Acceptance Criteria contract (optionally organized into ordered named groups); refine-spec hardens a draft into an accurate, not-over-engineered, implementation-ready spec via a grounded multi-pass review loop, commits the grounded AC group order, and hunts unstated non-functional constraints; launch-spec compiles a verified spec into one of three drivers (/goal, ultracode, /batch), each completed by a verify-spec gate on every acceptance criterion (emit-only), phasing a large or hard-sequenced build by AC group; verify-spec checks that the implementation actually matches the spec's claims and every acceptance criterion, grounded against the real code, git history, and live state — scaling each criterion's evidence standard and recording a per-AC verification method — and flags delivered code that maps to no criterion (backward coverage); on a spec re-run it drifts against the last clean verification, re-grounding only criteria whose evidence moved and flagging regressions. spec-ops commits the spec artifact at each stage (write the draft, refine the ready spec with Stop-hook enforcement, launch bakes a per-phase commit cadence into the /goal driver), each commit scoped to the spec file and never pushed. A verify→refine handoff carries verify-spec's backward-sweep proposed ACs to refine-spec via /tmp (hook-written), so a missed-requirement finding amends the spec on the next refine run without re-keying; verify stays read-only.
Fourth companion to `write-spec`, `refine-spec`, and `verify-spec`. It **compiles a ready spec into the driver `/goal` needs** — a goal, a checkable condition, explicit boundaries, and a `verify-spec` done-gate — then **quits**. `/goal` (native) does the implementing; you run the emitted prompt yourself.
Companion to `write-spec`. `write-spec` produces the foundational spec; this skill drives that spec — over **as many passes as it takes** — to a state that is **accurate, grounded, lean, and implementation-ready**, so the user can go straight from here into building. Loop until the readiness gate passes. Do not stop after one pass, and do not start implementing.
Fourth companion to `write-spec`, `refine-spec`, and `launch-spec`. `write-spec` drafts the spec; `refine-spec` verifies and tightens the **spec document**; `launch-spec` compiles the ready spec into a `/goal` driver that implements it; `verify-spec` verifies **reality against the claims** — whatever asserts them (a spec, an audit, or your own summary). It confirms that what was actually built (the committed code, the live system) matches what was claimed, grounding every claim in real source. It runs over **as many passes as it takes** until every claim has a definitive, evidence-backed verdict and a fresh judge agrees the verification is complete. **It edits nothing** — not code, not the spec — it grounds claims, reports discrepancies, and stops. Do not stop after one pass, and do not start fixing things unless the user asks.
`write-spec` always produces the **WHAT** (the behavior/contract), but at one of three depths. Read the requested rigor from the arguments (`rigor: light|standard|full`). If none is given, infer it from the ask — a self-evidently trivial change is `light`, a routine bounded feature is `standard`, a complex change or any infra / platform / config / migration spec is `full` — and **when unsure, default to `full`** (more rigor is the safe error). A caller delegating to this skill in batch (e.g. a board-intake workflow) passes the rigor explicitly; honor it.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Git worktree workflow for parallel Claude Code sessions, built on native worktree support: create-worktree spins up an isolated worktree and flips the session into it (fresh from origin, .worktreeinclude env files copied, optional issue/PR seed, opt-in setup script); list-worktrees shows a dashboard of every worktree (ahead/behind, dirty, PR, current marked); pull-worktree rebases/merges a worktree onto a chosen base branch; merge-worktree commits, pushes, opens/merges the PR into a chosen target, runs an opt-in teardown script, then removes the worktree and returns to main.
A collection of Claude Code utilities by Zak Sakata
Ralph Loop — autonomous agentic coding workflow with sandbox isolation, scoped memory, and self-managing task iteration
Run a small team's entire software lifecycle on GitHub Projects v2 — deterministic, free, and GitHub-native. scaffold-repo copies a golden-template Project (fields, 8 views, 9 Insights charts) across the org and installs the repo automation (issue forms, PR template, board-sync + signals-sync workflows, the self-contained board-status deploy action, release notes, CODEOWNERS, no-squash merge setting); intake-issues turns a raw dump into tiered, AC-bearing issues by delegating the spec body + Acceptance Criteria to spec-ops (write-spec at the tier's rigor, refine-spec for T3) and sizing/Epic-splitting from the AC-group count; sync-signals recomputes the auto Gantt-signal fields (Schedule health, Slippage, Blast radius, Blocked) from the native blocked-by DAG and posts the project Status update. The board tracks the full branch -> PR -> staging -> prod flow with no hand-maintenance: Status writes are idempotent + monotonic across three loosely-coupled layers (native built-ins, the event-driven board-sync, the opt-in board-status deploy step), every Projects v2 write uses a GitHub App installation token (never GITHUB_TOKEN), schema edits diff before mutate to keep option/iteration IDs stable, and a skill-scoped PreToolUse guard blocks --squash and prod actions without green checks. No metered AI in Phase 1.
Manage Claude Code skills across any project and marketplace: configure which plugins a project uses, push local skills up to a central marketplace, keep them in sync, and remove them. Adapts to any repo layout. Authoring new skills is delegated to the native skill-creator skill.
npx claudepluginhub zakattack9/agentic-coding --plugin spec-opsA growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
Harness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
UI/UX design intelligence. 67 styles, 161 palettes, 57 font pairings, 25 charts, 15 stacks (React, Next.js, Vue, Svelte, Astro, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui, Nuxt, Jetpack Compose). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient.
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.