One Button Done Project

Plugin one-button-done-project in NoMoneyDaddy/One_Botton_Done_Project. Commands read from the repo's manifest — 1 month ago.

Skills (38)

• api-and-interface-design

  Design stable, explicit, hard-to-misuse interfaces across modules, APIs, services, and data contracts. Use when defining module boundaries, REST or GraphQL APIs, server actions, webhooks, or public function signatures.

• biome-quality-automation

  Use Biome as the JavaScript and TypeScript quality loop for formatting, linting, import sorting, safe fixes, and CI checks. Use when the project contains JS, TS, JSX, JSON, CSS, or GraphQL and you want one fast tool to automate code review and iterative cleanup.

• browser-testing-with-devtools

  Verify frontend behavior with real browser runtime data instead of static guessing. Use for UI bugs, console errors, DOM issues, network failures, performance checks, or visual verification in web apps.

• cavekit-backprop

  Turn bugs and failed tests into durable fixes by updating code, tests, and `docs/SPEC.md`. Use when a bug, regression, or invariant violation must be traced and prevented from recurring.

• cavekit-check

  Read-only drift checker for `docs/SPEC.md` versus code. Use before merge, before shipping, or when checking whether invariants, interfaces, and task status still match reality.

• cavekit-spec

  Maintain `docs/SPEC.md` as the structured spec source of truth. Use when turning an idea into a spec, distilling a spec from code, amending spec sections, or recording a bug back into the spec.

• ci-cd-and-automation

  Define repeatable automated quality gates for build, test, lint, deployment, and release workflows. Use when creating or changing CI pipelines, release automation, or environment promotion rules.

• code-review-and-quality

  Review changes across correctness, readability, architecture, security, and performance before merge. Use for pull requests, risky diffs, generated code, refactors, or any change approaching integration.

• code-simplification

  Simplify code without changing behavior so it becomes easier to read, test, and extend. Use when code works but is overly complex, duplicated, tightly coupled, or difficult to review safely.

• context-engineering

  Deliberately control what project context the agent reads, when it reads it, and how facts are persisted. Use at session start, on large repos, when token pressure is high, or when outputs start drifting.

• debugging-and-error-recovery

  Triage failures systematically to find root causes and recover safely. Use when tests fail, builds break, runtime behavior is wrong, deployments regress, or repeated fixes are not working.

• deprecation-and-migration

  Manage removal of old code, APIs, and workflows with explicit migration planning and compatibility windows. Use when replacing legacy implementations, renaming interfaces, or sunsetting behavior users still depend on.

• documentation-and-adrs

  Capture important decisions, project state, and maintenance-facing documentation as part of delivery. Use when making architectural choices, changing public behavior, completing milestones, or handing work to another agent or human.

• frontend-ui-engineering

  Build accessible, responsive, production-grade frontend UI with strong semantics and deliberate visual choices. Use for pages, components, layouts, stateful interactions, design-system work, and frontend refactors.

• git-workflow-and-versioning

  Keep changes reversible, reviewable, and well-versioned with disciplined Git usage. Use for all code changes, risky refactors, conflict resolution, and commit preparation.

• goal-loop

  Run a cross-platform session loop using repo files instead of platform-specific slash commands. Use when the user wants `/goal`-like behaviour but the workflow must stay portable across Codex, Claude Code, Cursor, Gemini CLI, Copilot, Hermes, or OpenClaw.

• idea-refine

  Turn a vague product or feature idea into a concrete buildable concept. Use when the user only has a rough thought, conflicting goals, unclear audience, or too many possible directions.

• incremental-implementation

  Implement work in thin vertical slices that keep the system runnable and testable after each step. Use when building any feature that touches multiple files, layers, or moving parts.

• interview-me

  Run a one-question-at-a-time interview to extract what the user actually needs before planning or implementation. Use when the ask is underspecified, conflicting, high-stakes, or the user only has a loose idea.

• loop-engineering

  Run the repository's end-to-end delivery loop from idea or legacy-project audit to plan, implementation, verification, documentation, and release preparation. Use when the user wants structured interactive guidance followed by persistent execution with minimal unnecessary stops.

• observability-and-instrumentation

  Add logs, metrics, tracing, and runtime signals so shipped systems are diagnosable and rollback decisions are evidence-based. Use before production launches, when adding critical flows, or when debugging incidents without enough runtime visibility.

• performance-optimization

  Optimize performance only after measuring and locating the bottleneck. Use when there are explicit latency, throughput, bundle-size, or Core Web Vitals goals, or when regressions are suspected.

• planning-and-task-breakdown

  Break a spec into small verifiable tasks with clear acceptance criteria. Use when a spec exists but the work is still too large, risky, or unclear to implement directly.

• project-config-generation

  Generate or align project configuration files after the stack has been confirmed. Use when a new project or legacy repo needs package.json, tsconfig, framework config, env examples, or quality config aligned to the chosen stack.

• recurring-monitoring

  Use when supervising PRs, deploys, long-running agents, flaky checks, external jobs, or any recurring watch task. Choose the right tool between session loop, hook, subagent, or CI, and define explicit success/failure/escalation exits.

• responsive-design-best-practices

  Apply responsive web design best practices for mobile-first layouts, fluid sizing, media queries, responsive images, and readable typography. Use whenever the UI must work well across phones, tablets, laptops, and wide screens.

• security-and-hardening

  Apply security-first engineering practices and hardening defaults. Use when handling user input, auth, secrets, storage, third-party integrations, webhooks, file uploads, or any untrusted external data.

• shipping-and-launch

  Prepare releases so they are observable, reversible, and safe to roll out. Use when deploying to production, planning rollouts, setting success metrics, or coordinating post-launch checks.

• source-driven-development

  Base framework, library, API, and platform decisions on official documentation or Context7 rather than memory. Use whenever correctness depends on current behavior, versions, configuration, or platform constraints.

• spec-driven-development

  Write or update a structured spec before implementation. Use for new projects, new features, major refactors, ambiguous requests, or any task that needs a shared source of truth.

• supabase-best-practices

  Apply current Supabase best practices for auth, RLS, schema changes, client/server separation, and production safety. Use whenever the stack includes Supabase database, auth, storage, edge functions, or SSR clients.

• test-driven-development

  Write a failing test or executable reproduction before implementation or bug fixing. Use for logic changes, regressions, bug fixes, refactors, and any behavior that should remain stable.

• text-to-lottie

  Generate or refine production-ready Lottie animations for web and app UI work. Use when a task needs motion graphics, animated SVG reveals, onboarding loops, loaders, hero motion, or reusable animation JSON.

• tool-discovery-and-installation

  Detect missing skills, MCP servers, CLIs, and sandbox tools; choose safe install paths; install or guide tool setup with explicit authorization and verification.

• typescript-best-practices

  Apply TypeScript best practices for strict mode, safe narrowing, tsconfig safety, robust error handling, and maintainable React/frontend code. Use whenever the stack includes TypeScript.

• ui-ux-designer

  Create interface designs, design systems, and UX improvements with accessibility-first guidance. Use for UI planning, component design, interaction quality, visual hierarchy, and design-system decisions.

• using-agent-skills

  Meta skill entrypoint. Select the right workflow skill for the current project phase, initialize required docs, and keep execution aligned with the project lifecycle.

• website-best-practices

  Build websites with strong semantic HTML, accessibility, performance, content structure, and predictable frontend behavior. Use for landing pages, marketing sites, dashboards, and general web UI work.

Similar plugins