dev-lifecycle

Plugin dev-lifecycle from marketplace eblouin-plugins in eblouin-development/eblouin-plugins. Commands read from the repo's manifest — 1 month ago.

Skills (34)

• accessibility-audit

  Run a thorough, whole-project WCAG 2.2 AA accessibility audit — fingerprint the UI surfaces, map semantics/landmarks, keyboard paths, focus management, contrast (against the design-system tokens), forms/errors, and media alternatives, credit what's already handled with evidence, run automated checks

• backend

  Build, modify, or review backend APIs following modern best practices. Use this skill WHENEVER the work involves the server-side application layer — API endpoints, request/response schemas, business logic, database models, queries, migrations, authentication/authorization, or background jobs. Primar

• client-comms

  Write client-facing communication about a project's real state — status reports, demo write-ups, plain-language release notes, and project handoff/offboarding packages. Use this skill WHENEVER the audience is the client rather than the team: \"status update for the client\", \"write the release note

• code-review

  Review code changes for correctness, breakage, best practices, DRYness, security, and performance/scalability, then either report what to fix (interactive) or take the change to merge-ready (in the coding-session pipeline). Use this skill WHENEVER the user asks to review code, check a diff or pull r

• coding-session

  Run the build of a whole feature end to end — from scoping (or picking up an already-scoped feature) through build and review to a single merge-ready PR — by orchestrating the firm's lifecycle skills as subagents, self-directing between the human gates. The human is in the loop at scope approval, at

• copywriting

  Write user-facing product and interface copy — microcopy (buttons, labels, empty states, error and success messages, tooltips), onboarding, notifications, and marketing/landing copy — in a consistent voice. Use this skill WHENEVER the work is words the end user reads in the product: \"write the copy

• data

  Create consistent seed/fixture data, build reporting, and own product analytics for a project — realistic development/demo/test data, the queries/exports/dashboards that answer questions about the app's data, and event instrumentation/capture for product metrics. Use this skill WHENEVER the work is

• debugging

  Systematically diagnose and root-cause a failure — a crash, an error, a wrong result, a flaky test, a performance problem, or a production incident — then fix it at the root and prevent recurrence. Use this skill WHENEVER something is broken or behaving wrong and the cause isn't yet known: \"why is

• dependency-maintenance

  Keep a project's dependencies current and secure — audit for outdated and vulnerable packages, plan and apply upgrades safely, and remediate CVEs. Use this skill WHENEVER the work is about the dependency graph rather than features: \"update our dependencies\", \"are we vulnerable to X\", \"bump this

• design-system

  Establish and enforce a project's visual design system — the design tokens (color, typography, spacing, radii, shadows, breakpoints), component conventions, and accessibility standards that the frontend skill's work (including its Tailwind / MUI usage) is written to defer to. Use this skill WHENEVER

• devops

  Set up and maintain infrastructure, containerization, and CI/CD for a web app — gated deployment, the build/test/deploy pipeline, environment and secrets management, and the operational side (migrations on deploy, observability, rollback). Use this skill WHENEVER the work involves Dockerfiles or Com

• discovery

  Turn a vague client brief into concrete, client-confirmable requirements — generate a client-interview guide to prep for a call, then synthesize raw notes/transcripts into a requirements document that keeps STATED FACTS separate from ASSUMPTIONS in an explicit assumption log. Use this skill WHENEVER

• documentation

  Write and maintain technical documentation for a codebase — READMEs, API references, architecture decision records (ADRs), changelogs, contributing/onboarding guides, and inline docstrings/comments. Use this skill WHENEVER the work involves documenting code or a project: \"write a README\", \"docume

• final-review

  The last-mile review the live agent runs ITSELF — never delegated to a subagent — on a finished PR before flipping it ready for the human: production readiness, security, comment relevance (no changelog-style comments in code), information placed where it belongs (PR/issue, not comments), and the FU

• frontend

  Build, modify, or review frontend web UI following modern best practices. Use this skill WHENEVER the work involves the client-facing layer of a web app — React components, pages, hooks, state, forms, styling, or server-rendered HTML/templates with HTMX and Tailwind. Trigger it for \"build the UI fo

• infrastructure

  Provision and maintain the infrastructure that apps run on — cloud (AWS via IaC), a home/beta server, or a VPS — and keep it healthy over time: networking (Tailscale), backups, monitoring, updates/patching, TLS, access control, and resilience/auto-recovery. Use this skill WHENEVER the work is about

• mobile

  Build, modify, or review a React Native / Expo mobile app following modern best practices. Use this skill WHENEVER the work involves the mobile client layer — Expo/React Native screens, navigation, native modules, mobile auth, or wiring the app to the shared API client. Trigger it for \"build the mo

• modernization

  Migrate an EXISTING repository you OWN onto the monorepo starter kit — assess the legacy app against the kit's catalog (keep/wrap/replace per part, honest about what has no counterpart), plan a staged strangler-fig migration filed as a GitHub epic + stage issues, then orchestrate each stage through

• onboarding

  Bring an EXISTING repository into the firm so you can work it through the pipeline — detecting whether you own it (full setup) or are a guest (zero-footprint setup). Use this skill WHENEVER you point Claude at a repo that already exists and want it firm-ready: \"onboard this repo\", \"set me up to w

• performance-audit

  Run a thorough, whole-app performance audit — fingerprint the application, map every applicable performance surface (backend query plans/N+1s/indexes/payload sizes, frontend bundle size/Core Web Vitals/render waterfalls), credit what's already fast with evidence, identify slow paths, run a safe load

• planning

  Produce a clear, actionable implementation plan before any code is written, then — once the user approves it — file it as a GitHub issue and hand it to the build pipeline. Use this skill WHENEVER the user asks to plan, scope, design, or \"figure out how to approach\" anything — a new project, a feat

• privacy-compliance

  Run a whole-project privacy and regulatory-compliance posture audit — data inventory (what personal data exists, where it lives, how long it's kept), lawful-basis/consent posture, DSAR readiness (do export and erasure paths actually work?), cookie/tracker inventory, processor list, and breach-notifi

• product-planning

  Create the overarching plan for a whole product — the north star that keeps everything aligned — and break it into stages you build one at a time. Use this skill WHENEVER greenfielding a whole product or a major new system, or when the request is about the big picture rather than one feature: \"plan

• recipe-author

  Author a new feature recipe for this plugin's monorepo starter kit — what it wires across which blocks, its prerequisites, its wire-up steps, and its portable doc fragment, per the recipe template. Use this skill WHENEVER extending the starter kit's recipe catalog: \"add a feature recipe\", \"write

• repo-audit

  Run a whole-repository, all-dimensions analysis in one pass — security, performance, accessibility, privacy, SEO, code quality, and dependency health — by fingerprinting the repo, fanning out across the applicable specialist audit skills as subagents, and rolling their findings into a single priorit

• scaffolding

  Bootstrap a new or empty repository into the firm by COMPOSING it from the starter kit — the monorepo skeleton, template blocks (backend/frontend/mobile/infra), catalog components, and feature recipes under ${CLAUDE_PLUGIN_ROOT}/templates/ and references/recipes/ — plus the CI gates and branch prote

• security-audit

  Run a thorough, whole-project security audit — fingerprint the application type, map every applicable attack surface, credit what's already mitigated with evidence, identify open vulnerabilities, deliver an inline audit report, and (after one confirmation) file each finding as a scoped, pipeline-rea

• seo

  Technical and on-page SEO for client sites — an audit mode (read-only, patterned after security-audit: crawlability, meta/canonical/robots, structured data validity, Core Web Vitals implications, rendering-strategy tradeoffs, index coverage) and an implementation mode (metadata conventions, sitemap/

• technical-proposal

  Produce a technical proposal for building something — the recommended stack and why, the high-level architecture, and an honest cost/timeline estimate — so a build/no-build decision can be made before any code or roadmap. Use this skill WHENEVER the question is whether and how to build a system: \"w

• template-author

  Author a new template block or catalog component for this plugin's monorepo starter kit — decide its placement, fill its composition contract (needs/exposes), and clear the four acceptance bars (composition-contract, documented, version-pinned, secure-by-default) before it ships. Use this skill WHEN

• testing

  Design a test strategy and write the test suite — unit, integration, and end-to-end — for backend and frontend code. Use this skill WHENEVER the work involves writing or improving tests: \"write tests for X\", \"add test coverage\", \"set up testing\", \"test this endpoint/component\", \"I want to T

• ui-exploration

  Explore net-new UI — a new screen, feature look, or a product's visual direction — and turn the chosen direction into an implementable spec. Use this skill WHENEVER the work is figuring out what something should look like before building it: \"design a screen for X\", \"explore some directions for t

• walkthrough

  Explain a file, a section/subsystem of a repo, or a pull request in depth — what the code does, WHY it was built that way (decisions, tradeoffs, constraints), and what future considerations matter — as inline, human-readable markdown with links to the relevant docs and code. Use this skill WHENEVER

• web-proposal-writer

  Write the persuasive, client-facing sales proposal for a website/app build — problem framing in the client's language, the recommended approach, what's included and excluded, timeline, investment framing, and a clear next step. Use this skill WHENEVER the work is winning the client's yes on a build:

Similar plugins