3.9K skills · sorted by relevance
Map an existing codebase into seven documents covering its technology, structure, architecture, conventions, integrations, tests, and concerns. Link findings to file evidence, mark unknowns, and highlight differences between stated plans and the actual implementation.
Coordinate a small AI development team with planning, implementation, and optional independent testing roles. Adapt the process to the work’s complexity, prepare pull requests, and preserve decisions and next steps so later sessions can continue.
Send questions, review requests, or implementation tasks to a supported local AI command-line tool through one shared command. The wrapper handles provider-specific options and saves the result as a Markdown file for later reference.
Turns vague development requests into reviewed plans through planning, architecture, and quality-review agents. It compares alternatives, defines testable acceptance criteria, and records decisions, stopping before implementation unless execution has been explicitly approved.
Develop an implementation plan through sequential Planner, Architect, and Critic reviews. Compare options, document risks and acceptance checks, and preserve the plan and review records for a later handoff to `$ultragoal`.
Turn a feature idea into a design document through focused dialogue. The skill clarifies goals and constraints, compares two or three approaches, and reviews the design in sections before documenting architecture, data flow, errors, and testing.
Build and improve mobile apps with React Native and Expo using prioritized implementation rules. Covers faster lists, animations, images, navigation, state management, and native dependencies, with explanations and code examples for reviewing common implementation choices.
Turn a Zoom integration idea into a recommended architecture and implementation path. The skill identifies the task, selects the appropriate Zoom technology, and routes requests to focused skills for authentication, meetings, bots, AI workflows, or debugging.
Compare SDK implementation with English documentation to find missing features, incorrect defaults, and outdated behavior descriptions. Report evidence and suggested locations, or make requested updates while keeping navigation consistent and following the repository’s documentation checks.
Turn a Factory work item into a phased implementation plan grounded in current code and project history. Document scope, changes, tests, risks, and assumptions, then hand the plan to the execution stage.
Guide substantial qwen-code feature development from investigation and design through implementation, testing, and review. Produce design documents and end-to-end test plans, compare behavior before and after changes, and address verified review findings.
Plan features before coding by defining requirements, acceptance criteria, and scope. Validate the specification, generate starter tests from expected behaviors, and guide implementation and review so each delivered feature can be checked against its agreed requirements.
Find code components that match Figma design components by comparing names, structure, and settings. Presents candidates for approval, then creates Code Connect mappings, explicit links between design components and their implementations.
Create project-specific rules for turning Figma designs into code. The skill examines existing components and styling, then saves conventions for naming, file locations, reusable design values, and implementation steps in the coding agent's rule file.
Implement pending tasks from an OpenSpec change, a planned set of development work. The skill reads relevant specifications and design files, makes focused code changes, and updates task completion as work progresses.
Coordinate a game interface feature from user experience specifications through visual design, implementation, review, and polish. Reuse existing interaction patterns and report input support, accessibility checks, engine validation, and unresolved issues alongside the delivered interface.
Turn a plan, specification, or concrete development request into implemented changes with local verification. Run it independently for a review and delivery handoff, or return implementation results to a calling workflow.
Turn a named NemoClaw issue into an implementation plan with clear ownership, scope, completion criteria, and validation evidence. For larger changes, define independently useful steps, their dependencies, and delivery order.
Execute development subtasks under a supervising agent, starting with an implementation plan and impact analysis. Deliver code and a three-question self-review in a defined completion format for the supervisor to assess.
Create an SEO strategy for a new or existing website, tailored to its industry, competitors, goals, and resources. Produce a site structure, content calendar, technical priorities, and phased implementation roadmap with measurable targets.
Audit an app’s animations for responsiveness, performance, and accessibility, then rank the findings by impact and effort. Produce detailed implementation plans that another agent can follow, while leaving source code unchanged during the audit.
Work through design or implementation choices one at a time, with concise context and clear alternatives. You can also review completed code change by change, recording decisions, approvals, and requested revisions in a final table.
Turn a feature idea into a specification through structured questions about users, business goals, and technical constraints. Produce requirements, user stories, testable acceptance criteria, and an implementation checklist, including performance, security, and error handling.
Model distributed systems and concurrent algorithms in TLA+ or PlusCal, then check possible states with TLC. Use the results to investigate deadlocks, broken rules, and differences between specifications and implementation code.