8K skills · sorted by relevance
End-to-end Jira ticket implementation — fetches ticket, creates branch, implements changes, builds, commits, pushes, and creates a PR. Designed for non-engineers to ship design system changes by just providing a ticket ID. Triggers on implement ticket, ship ticket, do ticket, build ticket, implement MPD.
The English summary is being prepared. Showing the original description.
Guides feature development and bug fixes by writing tests before implementation. It confirms each test fails for the expected reason, adds only enough code to pass, and checks the full test suite before completion.
Turn a specification and its tickets into code by coordinating multiple agents around task dependencies. Combine their work on one integration branch, use test-driven development, review the result, and close tickets through the issue tracker’s workflow.
Organize feature development using files in the repository. Break larger goals into user stories, assign them to sprints, guide implementation and review, and track progress through confirmed merges without an external project management tool.
Map the impact of a proposed change using real dependencies and project documentation. Identify affected code, data, interfaces, tests, and release steps, then compare the implemented changes with the plan to expose gaps and unverified risks.
Coordinate a new feature from research and planning through tests, implementation, review, and commit. Assign phases to matching ECC agents, write failing tests before implementation, and pause for approval of the plan and before committing.
Turn clear requirements into small implementation tasks with acceptance criteria, verification steps, dependencies, and estimated scope. Produce a written plan and ordered task list, with checkpoints and opportunities for parallel work identified before coding begins.
Implement larger changes as small, working pieces. Each piece goes through testing, verification, and a focused commit, with guidance on choosing boundaries, hiding unfinished features behind switches, and keeping changes easy to roll back.
Turn Figma designs into production-ready frontend code that closely matches the original visuals. Use it to hand design frames directly to a frontend agent and guide implementation toward a faithful reproduction of the design.
Implement animated effects, transitions, and movement in Flutter apps. Use it when adding motion to native iOS and Android app interfaces, with support for turning requests for animation into implementation work.
Create a phased implementation plan for a feature or complex development task. It investigates documentation and existing examples, identifies supported APIs, and records concrete tasks, references, and verification checks for each phase.
Carry out a phased implementation plan with subagents assigned to implementation, verification, pattern checks, and code review. Each phase must pass verification before changes are committed and pushed, with context prepared for the next phase.
Turn an approved specification into pseudocode, a plain outline of program logic, and an architecture defining module responsibilities and API inputs and outputs. After user confirmation, proceed with implementation and unit tests based on those designs.
Compare an implementation with its OpenSpec specifications, tasks, and design decisions before archiving the change. Get a report on completion, requirement coverage, and consistency, with prioritized issues, actionable recommendations, and explicit limits where evidence is missing.
Research existing code, documents, and relevant sources before producing a practical plan for implementation, migration, debugging, or evaluation. The plan explains key decisions, ordered steps, and validation checks, giving users something concrete to review before execution.
Implement approved development stories and code changes with Amelia, a senior software engineer persona. Follow a test-first process: write a failing test, make it pass, then improve the code while checking every acceptance criterion.
Implement or review login and access controls for applications and APIs. Helps define token lifetimes, session handling, and permissions for specific resources, with checks for user identity, organization boundaries, credential storage, and authentication failures.
Manage coding work from issue intake through implementation, review, deployment, and acceptance checks. Track each completion requirement against fresh evidence, with defined retry limits and explicit escalation when progress needs human input.
Assess a new or existing AI project by examining its code, goals, and constraints. Recommend skills confirmed to exist in the available registry, then outline tasks and implementation phases with dependencies, completion criteria, and checks.
Coordinate a development task from planning through implementation and review. Choose whether to proceed after seeing the plan, then receive a report covering commits, verification results, review findings, and any work left unfinished.
Guides contributors through adding a new programming language to Airflow, covering SDK structure, runtime coordination, communication rules, executable packaging, tests, and the documentation and configuration changes needed for a pull request.
Design and implement interface responses such as button feedback, loading indicators, page transitions, and swipe gestures. Use motion to communicate actions and state changes, with guidance on timing, performance, and support for people who prefer reduced animation.
Plan and implement user login and access permissions using sessions, JWT tokens, or OAuth2. Apply role-based permissions, protect APIs, and review common weaknesses in password handling, cookies, token expiration, and server-side checks.
Review and write Solidity smart contracts with security in mind. Address reentrancy, where external calls trigger repeated execution, along with numeric overflow and access control issues, using implementation patterns, security tests, and documentation for audit preparation.