addyosmani

Teams often lose time choosing the right workflow for a software task. This skill maps task context to focused agent skills and a practical development sequence.

Teams need reliable ways to implement changes and fix bugs without relying on intuition or fragile manual checks. This skill guides a red-green-refactor workflow with repository-aware commands, focused tests, and full-suite verification.

Unclear requirements cause rework, missed assumptions, and poorly ordered implementation tasks. This skill guides teams through reviewed specifications, dependency-aware plans, and verifiable tasks before coding.

Framework guidance becomes outdated as APIs and recommended patterns change. This skill verifies versions, follows current official documentation, and cites sources for each decision.

Production releases can fail without clear gates, monitoring, and rollback criteria. This skill creates a structured launch plan for controlled, observable deployment.

Security reviews can miss trust boundaries and unsafe data flows. This skill supplies threat-modeling prompts, OWASP patterns, and practical review checklists.

Performance problems are difficult to diagnose when teams optimize from assumptions. This skill provides a measurement-first workflow for finding bottlenecks, testing fixes, and preventing regressions.

Production teams need reliable evidence when services fail, slow down, or behave unexpectedly. This skill helps design useful logs, metrics, traces, alerts, and verification steps.

Large changes are difficult to test, review, and recover when problems appear late. This skill breaks work into complete increments with explicit tests, verification, and rollback points.

Unstructured branches, oversized commits, and unclear releases make changes difficult to review, revert, and communicate. This skill provides practical Git workflows for disciplined changes, safe collaboration, and predictable versioned releases.

Vague ideas often hide weak assumptions and unclear priorities. This skill expands options, tests directions, and produces a focused one-page brief for action.

Frontend work can become inconsistent, inaccessible, or difficult to maintain. This skill guides component architecture, responsive layouts, state handling, and polished user experiences.

Long sessions can turn assumptions into accepted facts and hide costly failure modes. This skill applies bounded, fresh-context adversarial review before non-trivial decisions stand.

Legacy systems create maintenance cost and migration risk. This skill provides staged plans, compatibility checks, and rollback guidance for controlled change.

Debugging failures by guesswork wastes time and can hide the real cause. This skill provides a repeatable process for reproducing, isolating, fixing, and verifying problems.

Teams often lack measurable quality standards, allowing checks and thresholds to drift during development. This skill defines a shared contract and connects each constraint to practical enforcement.

Coding agents lose accuracy when context is incomplete, stale, or excessive. This skill provides practical structures for focused sessions, durable rules, and reliable handoffs.

Complex code slows reviews, maintenance, and debugging. This skill guides focused refactoring that improves clarity while preserving behavior, errors, side effects, and tests.

Teams need repeatable checks and controlled releases to reduce broken builds and deployment risk. This skill provides practical pipeline, testing, rollout, secret, and rollback guidance.

Unclear contracts, inconsistent errors, and unsafe retries make APIs difficult to use and evolve. This skill provides practical patterns for typed interfaces, validation boundaries, compatibility, pagination, and idempotency.

Browser bugs can hide behind static code and incomplete unit tests. This skill uses Chrome DevTools MCP to inspect live behavior and verify fixes with runtime evidence.

Large or vague software work can hide dependencies, missing acceptance criteria, and verification gaps. This skill converts a specification into ordered task slices with checkpoints, scope guidance, and clear completion conditions.

Underspecified requests cause teams to build the wrong outcome and discover misalignment late. This skill runs a focused, one-question interview that turns ambiguity into confirmed intent.

Teams lose context when important technical decisions remain in chat, code comments, or individual memory. This skill turns architectural reasoning, API guidance, project instructions, and release changes into structured documentation.