Coding standards, frameworks, refactoring, and code review (15.8K skills)
Convert Python browser-use scripts into TypeScript workflows using Stagehand v3 on Browserbase. Separate predictable steps from actions that need AI, and provide runnable project setup plus a migration summary identifying features that require human review.
Turn recorded browser traffic into an OpenAPI 3.1 specification, a standard format for describing APIs. Infer endpoints and data structures from observed requests, and generate client code plus reports showing examples, confidence, and coverage gaps.
Improve automation for specific website tasks by repeatedly running them, reviewing execution records, and updating navigation instructions. Turn the resulting workflow and recovery steps into a reusable Claude Code skill, with optional runnable script generation.
Integrate WebMCP tools, app capabilities that AI agents can call, directly into an existing web application. Inspect its source code, preserve existing validation and permissions, and verify tool discovery, execution, and actual changes in application state.
Create WebMCP tools, browser features that AI agents can call, for a specific website. Starting from a URL and desired task, generate an initialization script and validate tool registration and execution with Stagehand.
Review a technical design against requirements and existing code patterns to assess implementation readiness. Highlight up to three critical concerns, recognize strengths, and provide a reasoned GO or NO-GO decision with actionable next steps.
Create and maintain project reference documents from the codebase, covering product purpose, technology choices, and organization patterns. Detect differences between documentation and code while preserving user additions during updates.
Create requirements, a technical design, and implementation tasks from a feature description. Choose step-by-step approval or automatic execution, then review the generated documents for contradictions, missing prerequisites, and gaps in task coverage.
Implement approved tasks using test-driven development, writing tests before code. Run all pending tasks one at a time or select specific tasks, with configurable review and verification before updating completion status.
Compare feature requirements with an existing codebase to identify missing capabilities and integration challenges. Evaluate extending existing code, building new components, or combining both, then save findings and open research questions to inform the design phase.
Document a project's purpose, technical choices, and organization patterns as persistent reference files for agents. Compare existing guidance with the codebase, identify mismatches, and propose additions while preserving user-written content.
Create requirements, designs, and task lists for multiple roadmap features in dependency order. Independent features run in parallel when supported, followed by checks that shared data, interfaces, naming, and work boundaries agree across specifications.
Turn a project description and existing project guidance into a requirements document. Organize expected behavior into EARS statements, a structured format for clear conditions and outcomes, and review coverage, ambiguity, and scope before saving.
Turn pending roadmap features into requirements, technical designs, and implementation tasks. Independent features run in parallel, while prerequisite features finish first. A final review checks shared data, interfaces, naming, and responsibility boundaries across specifications.
Review a technical design before implementation by comparing it with requirements and existing code patterns. Receive up to three critical concerns, recognized strengths, and a clear decision on whether to proceed, with reasons and practical next steps.
Create requirements, designs, and implementation tasks for multiple roadmap features in dependency order. Use parallel workers when available and permitted, or process sequentially, then check consistency across specifications.
Investigate blocked implementation work and recurring failures using error output, code changes, configuration, and dependency evidence. Get a root cause report with a focused repair plan, verification steps, and a recommendation to retry, block, or seek human input.
Turn a feature description and project guidance into a requirements document with testable acceptance criteria. Review coverage, ambiguity, and scope before saving, using EARS, a structured format for describing system behavior and conditions.
Turn requirements into a reviewed technical design. Examine existing code and relevant technologies, define component responsibilities and interfaces, plan files and tests, and record research findings and the reasons behind design decisions.
Clarify a development request through structured questions and choose a practical next step: update an existing specification, create new ones, or implement directly. For new specifications, record scope, approach, and dependencies in planning files.
Turn requirements and design documents into implementation tasks sized for one to three hours each. Check requirement coverage, dependencies, and observable completion criteria before saving a reviewed task plan.
Generate requirements, technical designs, and implementation tasks for pending roadmap features in Cascade. Features are processed one at a time in dependency order, followed by a review of consistency and responsibility boundaries across specifications.
Implement approved development tasks one at a time using test-driven development, which starts with a failing test. Process all pending tasks or selected ones, check changes against requirements and design, and update progress after review and completion verification.
Review a completed implementation task against approved requirements, design, and assigned scope. The skill inspects code changes and verification evidence, checks tests and hidden dependencies, and returns an approval or rejection with specific findings and required fixes.