everyinc/compound-engineering-plugin
46 skills63k installs944k starsGitHub
Install
npx skills add https://github.com/everyinc/compound-engineering-pluginSkills in this repo
1Coding TutorCoding Tutor is a generator-oriented agent skill backed by a small Python CLI that creates new coding tutorial templates with proper YAML frontmatter. Solo builders and technical educators use it when they want repeatable lesson structure—topic title, optional concept tags like Redux or Context, and a home outside the main app repo—without hand-rolling every file. The workflow checks the current git repository name, surfaces uncommitted-change warnings so tutorials do not drift from a dirty tree, and slugifies human titles for stable paths. It fits indie teams shipping courseware, internal onboarding docs, or open-source learning tracks alongside a SaaS or content product. Pair it with your agent when you are in active build mode and need documentation that agents can extend incrementally rather than one-off chat explanations.2.3kinstalls2LfgLFG is a compound-engineering workflow skill for solo and indie builders who want autonomous, end-to-end software delivery instead of ad-hoc coding sessions. You invoke it only when you explicitly ask for hands-off execution and supply a feature description; casual chat should not route here. The agent must run every step in order, starting with ce-plan and a hard gate that requires a written plan in docs/plans/ before any build work. It then walks through implementation, review, testing, version control, pull request creation, and CI monitoring with fixes until pipelines pass. That ordering matters because skipping planning produces unreliable output. It integrates with the plugin’s ce-plan and related skills using verbatim entries from the host skill list. Ideal when you already trust your repo conventions and want one orchestrated run from spec to merge-ready green CI.1.8kinstalls3Ce BrainstormCe-brainstorm is a compound-engineering methodology skill for turning exploratory dialogue into a requirements artifact—or deliberately not—when a durable doc would be overhead. It states what excellent brainstorm output must deliver: enough framing that `ce-plan` or a human planner never invents user behavior, scope edges, or success metrics; enough transparency that reviewers see pinned versus open choices; and enough narrative that a future reader understands why the work matters and for whom. The skill also gives a clear gate for skipping document creation when the conversation only needed light alignment and decisions can ride directly into planning, commits, or solutions docs. Solo builders running agentic product workflows use it anytime they are about to shape a feature, integration, or refactor and need disciplined scope before code.1.7kinstalls4Ce Plance-plan is a journey-wide agent skill from the compound-engineering plugin for solo builders who need judgment before commitment. It answers requests one altitude up: instead of immediately producing the final artifact, the agent runs cheap grounding recon on whatever inputs you provided—skimming structure and relationships, not doing the full read or build—and composes an approach-plan that names concrete bridges (for example, which sections of a PDF or which modules in a repo matter). You approve, defer, or redirect at a checkpoint; only after that does execution-style work belong elsewhere (ce-work for code). That makes it useful at Idea when orienting on messy sources, at Validate when scoping a prototype or doc, at Build when you want an implementation strategy without premature coding, and at Ship when planning a review or test campaign. The skill optimizes for specificity over boilerplate checklists so the checkpoint is worth your time. It is planning and knowledge-work only; agents should not treat it as permission to patch repositories or run commands.1.7kinstalls5Ce Compoundce-compound is a Compound Engineering skill that gives solo builders ready-made resolution templates so every fix becomes searchable institutional memory instead of chat scrollback. You pick a problem_type track—bugs spanning build, test, runtime, perf, DB, security, UI, and integrations, or knowledge gaps around practices and DX—and fill a consistent markdown plus YAML frontmatter structure. The workflow pushes observable symptoms, failed attempts, working solutions, and prevention guardrails into docs/solutions style paths. It is most valuable when you are iterating after ship: debugging, reviewing incidents, or closing documentation holes. Multi-phase use is normal: capture test failures during Ship, runtime issues during Operate, and workflow lessons during Build. The skill is template-first meta guidance, not an automated scanner.1.6kinstalls6Ce Workce-work is the execution command in the Compound Engineering plugin: it ingests either a path to a plan or specification or a short description of work, then runs a phased workflow focused on finishing features without quality drift. Phase zero decides whether you already have a plan document or need a quick reconnaissance pass—listing probable files, locating tests that cover them, and classifying trivial versus substantive change before coding. The skill steers agents toward pattern-following implementation, environment setup when needed, and explicit complexity routing instead of one-size-fits-all hacking. Solo builders benefit when they have moved past brainstorming and planning and want a disciplined “work the doc” pass that respects existing test layout. It pairs naturally with upstream planning skills and downstream review or ship steps in the same plugin family.1.6kinstalls7Ce Debugce-debug is a procedural debugging skill for solo builders and small teams who want agents to stop guessing at patches. It treats every bug as an investigation: you describe the failure (issue link, stack trace, failing test, or broken behavior), and the workflow forces a complete causal explanation from trigger to symptom before any code change. When links in that chain are uncertain, the skill requires predictions—observable consequences elsewhere—that must hold if the proposed cause is real. Fixes proceed one variable at a time, which keeps bisection honest in messy codebases. The skill fits Claude Code, Cursor, Codex, and similar agents whenever debugging stalls after repeated failed attempts or when users say “debug this,” “why is this failing,” or paste errors from GitHub, Linear, or Jira. It is methodology, not a single integration: use it during test red runs, staging repros, and post-deploy regressions alike. After a confirmed root cause, the same skill can guide a minimal fix validated against the original failure mode.1.6kinstalls8Ce Ideatece-ideate is a post-ideation workflow slice from the Compound Engineering plugin. After parallel Phase 2 ideation agents finish and the orchestrator merges duplicate candidates, this skill defines Phase 3 adversarial filtering: the orchestrator reviews each idea directly, applies strict rejection rules—from vagueness and duplicate coverage to unjustified claims, subject-replacement pivots, and scope overrun—and records a one-line rationale for every drop. It respects Phase 0.5 tactical focus signals that can waive the ambition floor. Solo builders using multi-agent product loops get a disciplined gate that keeps brainstorming output aligned with stated context and existing docs instead of inflating backlogs with fantasy features. It is not early brainstorming; invoke it only when the master candidate list already exists.1.6kinstalls9Ce Doc Reviewce-doc-review is a compound-engineering document review skill that treats requirements and plan markdown as reviewable artifacts, not final truth. Solo builders drafting specs before Cursor or Claude Code implementation can dispatch parallel persona reviewers, accept automatic safe fixes, and decide what to do with the rest through a structured four-option flow (walk each finding, auto-resolve with judgment, append open questions, or report only). Interactive mode expects Claude Code to preload AskUserQuestion early via ToolSearch; Codex, Gemini, and Pi skip that preload. Headless mode supports unattended passes when you pass the path and mode flag. The skill fits Validate and Ship mentally—tighten scope before build, and re-run on launch plans—but Prism shelves it under Validate scope as the first place a solo founder should run it on a new idea write-up.1.6kinstalls10Ce SetupCe-setup documents the optional local configuration file for the Compound Engineering plugin—intended to be copied to .compound-engineering/config.local.yaml at the project root. Solo builders adopting Compound Engineering use it to turn on Codex work delegation with explicit consent and sandbox modes, and to wire product-pulse reporting to real analytics events such as session_started and task_completed. Every key is commented with allowed enumerations so you can adopt incrementally without breaking defaults. Re-run the related product-pulse skill with setup or reconfigure when you need interactive edits. This entry is meta configuration guidance, not a feature workflow; install the parent plugin first, then apply only the flags that match your risk tolerance for delegated coding and your event taxonomy.1.6kinstalls11Ce Sessionsce-sessions is a compound-engineering plugin skill aimed at solo builders and small teams who reuse prior agent work instead of re-litigating decisions in chat. Session retrieval is expected to return findings where named concepts (synthesis gate, ce-plan phases, etc.) still carry why they matter—not keyword stubs—because ce-compound Phase 2.4 depends on that resolution context. The bundled eval spec defines must/should/may term tiers, expected_context items, and a grader that checks preservation with rationale. Use when you are continuing compound-engineering work and need faithful recall of how features were designed and what problems they solved. Intermediate complexity: you should understand the plugin’s session store and downstream compound pipeline. It is meta-adjacent when used as an eval harness but practical when invoked to answer “what did we decide in ce-plan about X?” with terms intact for the next skill in the stack.1.6kinstalls12Ce Code ReviewCE Code Review is a Compound Engineering agent skill that standardizes how review findings are classified and handed off. Instead of a unstructured wall of nits, each issue carries an autofix_class—gated_auto for defensible localized fixes with suggested_fix, manual when product or architecture judgment is required, and advisory for valuable report-only observations. An owner field signals whether the caller, a human, or release ops should act. In agent mode the reviewer proposes and classifies; the caller owns what gets applied. In the default interactive flow, the skill can apply safe fixes by judgment per Stage 5c. Solo builders shipping with Claude Code use it to keep review output consistent across PRs and to prioritize what to fix now versus what to escalate.1.6kinstalls13Ce UpdateCE Update is a meta maintenance skill in the Compound Engineering plugin that tells your agent which marketplace build you are actually running. It ships small Bash scripts that inspect the on-disk path of the ce-update skill itself. When the path matches Claude's plugin cache layout—plugins/cache, marketplace folder, compound-engineering, version segment, skills/ce-update—it prints that version for upgrade flows. If the skill was copied elsewhere or symlinked outside the cache, it returns the sentinel __CE_UPDATE_NOT_MARKETPLACE__ so update logic does not guess wrong. Solo builders curating Claude Code marketplaces use it to avoid silent drift between documented SKILL.md behavior and the cached plugin revision.1.6kinstalls14Ce Optimizece-optimize is a compound-engineering template skill for solo builders who want agents to improve a scalar outcome—like build latency or search relevance—without gambling on regressions. You define a metric block (minimize build_seconds, gate on build_passed and test_pass_rate), point measurement at evaluate.py with timeouts and repeat stability, and fence which directories the agent may edit. The skill encodes execution mode, dependency approval, constraints, and when to stop iterating. It suits intermediate builders already running tests or eval harnesses who are tired of one-shot “make it faster” prompts that break CI. Use it in ship when perf or build time blocks releases, or in operate when you iterate on production-adjacent tooling—as long as you treat the measurement command as source of truth, not vibes.1.6kinstalls15Ce Compound RefreshCe-compound-refresh is an agent skill from the compound-engineering plugin that helps solo builders and small teams document how problems were actually solved—not just that the build went green. It provides resolution templates split into a Bug track for concrete failures (tests, runtime, security, integrations) and a Knowledge track for practices, documentation gaps, and workflow friction. Each entry uses schema-controlled YAML metadata so symptoms, root cause, and resolution type stay comparable across your repo over time. Install it when you are closing an incident or refactor and want a repeatable doc shape instead of scattering notes in threads. It pairs naturally with compound engineering workflows in Claude Code or Cursor where agent memory should compound into searchable solutions. The skill is template and metadata discipline, not an automated debugger or CI runner.1.6kinstalls16Ce Commit Push Prce-commit-push-pr is a workflow skill that takes local changes through commit and push to an opened pull request, with PR descriptions that grow in detail based on how substantial the change is. Solo builders use it when they want one commanded ritual—ship this—instead of juggling git CLI steps and generic PR templates. It also supports description-only runs when you only need a body for a new PR mental model or an existing PR reference, and a description-update path that resolves the open PR, previews copy, and applies after confirmation. The skill encodes platform-specific blocking question tools so agents do not guess on branch names, scope, or risky commits. It fits indie shipping cadence where the PR is the handoff artifact to future-you, collaborators, or automated review skills.1.5kinstalls17Ce Commitce-commit is a journey-wide git workflow skill from the Compound Engineering plugin that helps solo developers ship coherent version history instead of opaque “fix stuff” commits. When you say you want to commit, the agent inspects status and the diff against HEAD, reads recent commit style on the current branch, resolves the remote default branch when available, and drafts a single message that communicates value—not just file names. On Claude Code, context blocks are injected so the agent does not re-run noisy git commands; elsewhere it documents a one-shot fallback script for the same inputs. The skill targets staged or unstaged work on feature branches during Build, but it is equally appropriate before Ship reviews, Launch hotfixes, or Operate incident patches. Intermediate complexity assumes you already use git daily and want convention-aware messages without hand-writing every subject line.1.5kinstalls18Ce Slack Researchce-slack-research is an agent skill that searches Slack and returns a synthesized organizational research digest—decisions, constraints, and discussion arcs—rather than unprocessed message lists. Solo and indie builders use it when product or engineering context is scattered across channels and they need a single interpreted brief before validating scope, writing specs, or aligning with how the team actually talked about a topic. It accepts keywords, questions, channel hints (in:#channel), and date filters (after:YYYY-MM-DD), and asks for a topic when invoked bare. Install it when you repeatedly re-read old threads manually or when AI search over Slack needs editorial synthesis. It complements raw Slack lookup skills by adding cross-cutting analysis suited to AEO-friendly, cite-ready summaries for planning and retros.1.5kinstalls19Ce Demo Reelce-demo-reel is a compound-engineering agent skill that records a short product walkthrough as an animated GIF instead of a heavyweight video. Solo builders shipping web or localhost-accessible apps use it when they need credible UI proof for GitHub, docs, or social posts but do not want to babysit a screen recorder. The workflow connects through agent-browser, identifies how the app starts, optionally boots the dev server in headless environments, captures three to five frames at meaningful UI states, and stitches them with ffmpeg palette optimization. It is explicitly a Browser Reel tier: output is GIF, tools are agent-browser plus ffmpeg, and missing agent-browser triggers a clear install path via ce-setup before degrading to static shots or skip. The skill fits indie teams who iterate quickly and still want launch-quality visuals without a separate design pass.1.5kinstalls20Ce Agent Native ArchitectureAgent-Native Architecture is a compound-engineering discipline for solo and small teams building products where users and agents share the same capabilities. The skill frames agent-native design as continuous parity work: whenever the UI exposes an action—view library, add a book, publish to a feed—the agent must have a named tool and a system-prompt line that explains it. Without that map, users experience capable apps paired with helpless agents, which erodes trust fast. The overview walks through a concrete failure (publish to reading feed) and the fix (add publish_to_feed). Maintain a living capability table so reviewers and future you can see gaps before ship. This is methodology, not a single integration: it applies across Validate prototypes with agent hooks, Build feature PRs, Ship reviews, and Operate iterations when UI changes outpace tools. Indie builders using Claude Code or Cursor on a SaaS or agent product should treat parity as a default acceptance criterion alongside tests.1.5kinstalls21Ce Frontend Designce-frontend-design is an agent skill for solo builders who want production-grade web interfaces without the samey gradients and layout clichés common in AI-generated frontends. It walks a full lifecycle: detect what design system or patterns already exist in the codebase, plan intentional visual direction, implement with typography, color, motion, and copy discipline, then verify results through screenshots before marking work complete. Greenfield projects get stronger defaults; existing apps defer to established components and tokens. The skill is framework-agnostic in spirit—it cares about composition and craft rather than prescribing one stack. Use it whenever your agent is building or modifying landing pages, web apps, admin panels, or interactive experiences and you need a repeatable anti-slop process instead of one-shot JSX dumps.1.5kinstalls22Ce Dhh Rails Stylece-dhh-rails-style is an agent skill that teaches 37signals/DHH Rails architecture: CRUD-first routing, nested and singular resources, shallow URLs, and path-based multi-tenancy with tenant-aware cookies. Solo and indie builders shipping Rails SaaS use it when agents otherwise generate generic REST or deep nested routes that fight Hotwire and conventional naming. The readme walks routing draw blocks, verb-to-resource tables, middleware tenant extraction, and resolve helpers so generated code matches production Rails apps like Basecamp-style boards and cards. It is methodology plus concrete patterns—not a generator CLI—so it pairs with backend scaffolding and review passes before merge.1.5kinstalls23Ce Resolve Pr Feedbackce-resolve-pr-feedback helps solo builders and small teams clear GitHub pull request noise systematically. In Full Mode—triggered when you omit an argument or pass a PR number—the agent detects the PR from the branch if needed, runs the bundled get-pr-comments script, and receives structured JSON separating resolvable inline review threads from top-level PR comments and review submission bodies. It explicitly triages each item as new or already handled, including threads where someone replied but deferred work, so you do not duplicate fixes or miss stale blockers. Outdated inline comments remain visible with flags so resolutions account for line drift. The skill expects GitHub CLI and repository access; when automation fails it documents fallbacks through gh pr view and the pulls comments API. Use when review volume outpaces your attention right before merge, not as a substitute for design discussion on open questions you have not answered yet.1.5kinstalls24Ce Test Browserce-test-browser is a Ship-phase agent skill for solo and indie builders who want PR-scoped browser regression without standing up a separate Playwright suite for every change. You keep a local dev server running, confirm agent-browser is on PATH, then let the agent map affected routes from branch or PR context and drive real clicks, forms, and screenshots through the agent-browser CLI only. The workflow is opinionated on purpose: it rejects substitute browser MCPs and built-in browser tools so results stay comparable across Claude Code and Codex. Argument hints accept a PR number, branch name, current, or --port for non-default servers. When prerequisites fail, the skill tells you to run /ce-setup rather than half-running automation. Best fit when you already ship web UI and need fast confidence on changed pages before review or deploy, not when you need load testing or API-only coverage.1.5kinstalls25Ce Work Betace-work-beta documents the Codex delegation workflow inside the compound-engineering plugin for builders who split thinking and typing across Claude Code and Codex. When delegation_active is true, concrete implementation goes through codex exec while the orchestrating Claude agent keeps planning, review, git, and multi-unit batching. The skill encodes decision UX: ask mode surfaces recommended paths for single-batch versus multi-batch workloads and for all-trivial units where local Claude execution may be cheaper than delegation overhead; auto mode announces the batch plan without blocking. Choosing Claude sets delegation_active false and returns to standard parent-skill execution; choosing Codex continues into pre-delegation checks described in the parent work skill. This is intermediate orchestration knowledge—not a beginner 'write my app' shortcut—and assumes you already use the broader ce-work entrypoint. Pair it with review and test skills after delegated batches land so Ship gates still run on your repo.1.5kinstalls26Compound Docscompound-docs is an agent skill that locks in hard-won debugging outcomes as structured, categorized documentation the moment you confirm a fix worked. It is built for solo and indie builders who lose hours re-discovering the same N+1 queries, config quirks, or integration edge cases because nothing was written down. After phrases like "that worked" or a /doc-fix command, it runs a seven-step capture flow: detect confirmation, classify the problem against validated categories, and write a single searchable markdown file with YAML frontmatter under a symptom-specific path such as docs/solutions/performance-issues/. Preconditions require the problem to be solved and the solution verified, so the skill does not pollute the knowledge base with speculative notes. Filesystem writes, directory creation, and grep against existing docs keep duplicates visible. The result is a lightweight institutional knowledge base that pairs naturally with ship-time debugging and long-term operate workflows without replacing your main spec or planning skills.1.5kinstalls27Ce Release NotesCe-release-notes wraps a small Python fetcher for EveryInc’s compound-engineering-plugin GitHub releases so solo builders and agents can consume one predictable JSON payload. Success responses label the source as gh or anon, stamp fetched_at in ISO8601, and return releases with tag, version, name, published_at, url, body, and linked_prs derived from markdown PR references. Failures never throw to the shell; they return ok false with coded errors such as rate_limit or network_outage plus a user_hint, which makes the skill easy to chain in automation or agent workflows. Typical use is answering what changed between plugin versions before upgrading Cursor or Claude Code tooling, or drafting release summaries for a small team plugin you depend on. It is narrow by design: one owner/repo and a compound-engineering-v tag prefix, not a generic release tool for arbitrary repositories.1.5kinstalls28Ce Worktreece-worktree is a narrow, high-leverage git workflow skill from the Compound Engineering plugin. It wraps a bash worktree-manager script that does what raw git worktree add misses: copy local secrets and env files into the new tree, apply sane mise and direnv trust rules (stricter on review branches), and keep the primary checkout untouched while fetching the base branch. Solo builders use it when starting a feature in parallel, when ce-work offers a worktree path, or when ce-code-review needs an isolated tree for deep review. The skill is deliberately Bash-only through allowed-tools, with CLAUDE_SKILL_DIR resolution documented for Claude Code versus other agents. It is not a deployment or CI skill—it prepares a second workspace so your agent or you can commit on a branch without destabilizing the tree you are currently running.1.5kinstalls29Ce Gemini ImagegenCE Gemini Imagegen is an agent skill for Google's Gemini image API (documented as Nano Banana Pro) so solo builders can produce and revise visuals without leaving the coding agent. Invoke it when you need text-to-image assets, edits to existing PNGs, style transfers, branded logos with typography, stickers, or ecommerce-style product mockups, including chats that refine output over several turns or blend multiple reference images. The readme standardizes on gemini-3-pro-image-preview unless the user explicitly asks otherwise, with defaults for 1K resolution and 1:1 aspect ratio while listing optional 2K/4K and ratios from 9:16 through 21:9. For indies shipping landing pages, app store art, or in-app illustrations, it turns vague creative briefs into concrete API calls and guardrails. Prism lists it under generative build integrations rather than a separate design-only toolchain.1.5kinstalls30Ce Proofce-proof connects Compound Engineering workflows to Proof (proofeditor.ai), a collaborative markdown surface where humans and agents review the same document. Solo builders use it when a spec or plan needs eyes before coding—not when “proof” means evidence, a math proof, proof-of-concept, or a quick proofread. The skill supports creating and updating shared documents over the Web API and optionally driving the macOS Proof app through a local bridge. Every write must carry attribution: a machine ID on operations and headers plus a human display name on presence so comments and edits are traceable. It fits naturally after brainstorming or planning skills in the Compound stack, turning approved-in-principle markdown into a living review doc. You will use Bash, Read, Write, and WebFetch to integrate HTTP flows. The outcome is faster alignment on scope and fewer surprise rewrites because stakeholders comment in one place instead of scattered chat threads.1.5kinstalls31Ce Clean Gone Branchesce-clean-gone-branches is a small bash skill from the compound-engineering-plugin that lists local git branches whose remote tracking branch no longer exists—typically after a pull request merged and someone deleted the remote feature branch. Solo builders accumulate dozens of stale local branches; this script standardizes detection instead of manual `git branch -vv` grep. It fetches and prunes remotes, scans for the `: gone]` marker, strips worktree and current-branch markers, and prints safe candidate names one per line while never targeting the active checkout. Pair the output with your own delete confirmation or a follow-on automation step in your agent workflow. It is phase-specific Ship hygiene: fast, deterministic, and ideal for indie repos where you are both author and release manager.1.5kinstalls32Ce Agent Native Auditce-agent-native-audit is a Compound Engineering checker skill that runs a full agent-native architecture review against eight documented principles. Solo and indie builders shipping products where users and agents share the same workspace use it to see whether agents can do what users can, whether tools are capability primitives rather than baked behaviors, and whether UI reflects agent actions immediately. The workflow first invokes the agent-native-architecture reference material, then fans out eight parallel exploration sub-agents so each principle gets dedicated analysis before scores roll into one report. It fits after you have a working agent surface but before you treat the design as production-ready, and it pairs naturally with deeper refactors in Build as well as pre-launch checks in Ship when agent UX is on the critical path.1.5kinstalls33Ce Test Xcodece-test-xcode is a procedural agent skill for solo iOS builders who want a repeatable simulator test loop tied to XcodeBuildMCP instead of juggling xcodebuild commands manually. Invoke it after you change Swift or UI code and before opening a pull request, or whenever you need to confirm the app launches and behaves without obvious crashes. The skill begins by proving the MCP server is connected—listing simulators—and stops with clear install instructions if XcodeBuildMCP is absent. It then walks discovery of the workspace or project and scheme, runs against an available iOS Simulator, and emphasizes capturing screenshots and logs so you have evidence for review. It assumes Xcode with command-line tools and a valid Xcode project; it is not a device farm, TestFlight pipeline, or App Store submission checklist.1.5kinstalls34Ce Simplify Codece-simplify-code is a Compound Engineering workflow skill that acts like a disciplined refactor pass on recently changed code. Solo builders opening PRs can point the agent at a file, a morning’s edits, or—by default—the full diff against the base branch, and get simplification that follows project conventions while keeping functionality identical. The skill encodes a clear scope resolution order so agents do not accidentally rewrite unrelated modules, then demands test execution as the safety net. It fits indie teams who ship fast but want readable, explicit implementations instead of clever density. Use it after feature work and before review requests, or when iterating in Operate on hot paths you touched last—always paired with whatever test command the repo already defines.1.4kinstalls35Ce Strategyce-strategy is a facilitated strategy interview agent skill from the compound-engineering plugin. It loads at the start of Phase 1 and is revisited per section in Phase 2, walking you through the same sections as strategy-template.md. Instead of prescribing answers, the agent asks opening questions, evaluates responses against explicit quality bars, challenges weak answers using the user’s own words, and records final copy in the user’s language. Overall rules keep interviews tight: free-form for problem and persona, multi-select only for routing, at most two pushbacks before drafting with a revisit flag, and short 1–3 sentence answers so paragraphs cannot hide ambiguity. Solo and indie builders install it when they have momentum but a fuzzy thesis—before writing plans or coding—so downstream agent work rests on a defensible strategy artifact rather than improvised chat.1.4kinstalls36Ce Product Pulsece-product-pulse is the Compound Engineering Product Pulse first-run interviewer. Solo builders and small teams use it at the start of Phase 1 to turn fuzzy product language into a machine-local pulse configuration that every later CE run can reuse. The agent walks each config section with an opening question, applies named anti-pattern pushback once, and records answers in the team’s own vocabulary so `.compound-engineering/config.local.yaml` stays readable. Metrics must clear a SMART bar: specific named events, measurable definitions, and concrete signals rather than generic categories. When STRATEGY.md already defines the product or core metrics, those values seed defaults the user can edit instead of redundant questioning. The skill is explicitly not a secrets collector—it documents which analytics or data tool to query and what shape of query to run, while credentials remain in the operator environment. Outputs flagged as `needs-review` let you ship a partial config and refine on the next pulse cycle without stalling onboarding.1.4kinstalls37Ce Riffrec Feedback Analysisce-riffrec-feedback-analysis is a template-and-workflow skill from Compound Engineering that standardizes how agents digest Riffrec capture bundles into engineering-ready documents. Instead of vague bug reports, it forces findings with severity, observed versus expected behavior, cited evidence, and mapped requirement candidates. A second artifact shapes a requirements kickoff: problem frame, actors (user, product surface, assistant), key flows with triggers and outcomes, numbered requirements split between product behavior and reviewability, plus Given/When/Then acceptance examples and human success criteria. Solo builders and small teams use it after usability sessions or dogfood recordings to de-risk scope before coding. It pairs naturally with brainstorming and plan-writing skills when the zip is the source of truth.1.3kinstalls38Ce Polish Betace-polish-beta is an agent skill recipe used when Compound Engineering’s project detector returns Astro and no existing launch config is available. It tells your coding agent how to start the dev server with the correct package manager, which port to expect, and how to emit a minimal launch.json stub for repeatable polish sessions. Solo builders shipping marketing sites, docs, or content-heavy SaaS shells on Astro benefit because agents otherwise default to Next or Vite guesses and waste cycles on wrong ports or scripts. The skill lists common gotchas—lockfile precedence, `astro dev` behavior across output modes, and Astro config winning over raw Vite settings—so local preview aligns with what you actually run in the terminal. Invoke it during frontend build and polish passes when you want dev-server detection to be deterministic inside the compound-engineering plugin workflow, not when you need production deploy or Astro content authoring from scratch.1kinstalls39Dhh Rails Styledhh-rails-style encodes domain expertise distilled from 37signals production apps and DHH review habits. Solo builders shipping Rails SaaS products invoke it when writing or refactoring Ruby code so agents do not default to generic enterprise patterns—service layers, authorization gems, Redis caches, or GraphQL—that the 37signals stack deliberately avoids. The skill emphasizes rich domain models, REST purity, concerns for shared behavior, record-based state machines, Current attributes, and Hotwire-friendly controllers. It is equally useful when generating new features and when reviewing diffs for style drift. On Prism’s journey it lives on the build backend shelf but also supports ship review when you want opinions anchored in a known philosophy rather than neutral lint rules. Treat it as a stylistic contract for agents, not a security or deployment checklist.708installs40Frontend Designfrontend-design is an agent skill for solo and indie builders who want web interfaces that feel intentional—not interchangeable AI layouts. It applies whenever you are building or changing landing pages, marketing sites, web apps, dashboards, admin panels, components, or interactive experiences in Claude Code, Cursor, Codex, or similar agents. The skill starts by detecting whether the repo already has a design system or component patterns, then plans typography, color, motion, and copy around that context instead of overwriting it. A clear authority order keeps established tokens and libraries ahead of opinionated defaults unless you ask otherwise. After implementation, it expects visual verification via screenshots so you do not ship blind. It is intermediate in practice: you need a web project and basic frontend tooling, but you do not need to be a professional designer to get structured guidance.624installs41Gemini ImagegenGemini Imagegen is a Compound Engineering plugin skill for Google's Gemini image API (branded Nano Banana Pro in the doc). Solo builders use it whenever they need production visuals from a coding agent: landing heroes, app icons, styled edits, logos with readable text, stickers, and product mockups. The skill standardizes on gemini-3-pro-image-preview unless you override it, documents resolution defaults (1K with 2K and 4K options), and lists aspect ratios from square through ultrawide so exports fit social, mobile, and web layouts. It covers the core generate_content pattern in Python with types from google.genai, plus guidance for editing pipelines and multi-turn refinement when a first prompt is close but not ship-ready. Because it keys off GEMINI_API_KEY, it fits indie workflows where the builder already lives in the repo and wants the agent to script generation instead of context-switching to a separate canvas app.624installs42Git WorktreeGit Worktree is an agent skill that wraps a manager script around Git worktrees so solo builders can run parallel branches or isolated PR reviews without corrupting their primary working tree. It follows KISS-style interactive confirmations for create, list, switch, and cleanup, and it handles setup steps raw Git omits: copying common env files, keeping `.worktrees` in `.gitignore`, and applying cautious auto-trust for mise and direnv on trusted base branches while leaving review worktrees manual. Install it when you routinely context-switch between features, hotfixes, or review branches and want your agent to enforce one safe path instead of ad-hoc `git worktree` commands that leave sandboxes without secrets or tool trust.623installs43Agent Native ArchitectureAgent-native-architecture is a design skill for solo builders creating applications where autonomous agents are peers to traditional UI, not a sidebar chatbot. It explains why reliable agent loops (observe, act with tools, repeat until done) now enable general-purpose automation beyond coding, and it centers the parity rule: if a user can click it, the agent must be able to accomplish the same outcome through tools. Use it when planning MCP integrations, defining tool surfaces, or restructuring features as described outcomes rather than brittle scripts. The skill spans early Build agent-tooling and Integrations work and informs Ship security and Operate monitoring choices because agent permissions mirror product risk. It complements implementation skills by forcing architectural decisions up front—reducing rework when you later expose the same capabilities to Claude Code, Cursor, or custom SDK runners.569installs44Document ReviewDocument-review is a compound-engineering skill that improves requirements and plan markdown through multi-persona parallel analysis. Solo builders invoke it when a spec or plan exists but feels thin on edge cases, roles, or quality bar before coding starts. The workflow detects headless mode from arguments such as mode:headless plus an optional file path, then dispatches reviewer agents, auto-fixes issues with one clear correct fix, and returns present-class findings as structured text for the caller. Interactive mode can still ask strategic questions; headless mode preserves the same classification boundaries but skips AskUserQuestion-style approval loops and ends at Review complete. It fits indie teams who want document rigor similar to a lightweight design review without hiring reviewers. Pair it after drafting plans and before implementation or security review passes on the same artifact.550installs45Agent Browseragent-browser is an agent skill for programmatic browser work through a dedicated CLI on Chrome/Chromium and CDP. Solo builders reach for it when chat alone cannot click through a staging app, prove a checkout path, capture a screenshot for a launch asset, or pull structured data from a page. The documented workflow is deliberate: open the target URL, run snapshot -i to obtain element references such as @e1 and @e2, perform fills and clicks against those refs, then snapshot again whenever navigation or the DOM changes so selectors stay valid. Installation paths include npm i -g agent-browser, brew install agent-browser, cargo install agent-browser, agent-browser install for Chrome, and agent-browser upgrade for updates. It fits agents that already run shell tools and need reliable, repeatable browser automation without maintaining a separate Playwright script for every task.526installs46Every Style EditorEvery Style Editor is an agent skill that turns your coding assistant into a meticulous line editor aligned with Every’s comprehensive style guide. Solo builders and small content teams install it when they need consistent grammar, punctuation, mechanics, and brand-specific conventions across articles, newsletters, knowledge-base pages, and other written deliverables—not ad-hoc “sounds fine” passes. The workflow runs in four phases: understand document type and audience, sentence-level compliance review, formatting and consistency checks, then concrete improvement suggestions so humans can approve faster. It is a procedural checker, not a generic rewrite bot; invoke it whenever copy is near review or publish and you want deviations flagged systematically. It pairs well with drafting skills or human editors and reduces rework in growth and documentation workflows without replacing final editorial judgment.513installs