addyosmani/agent-skills

Features

• AI Agent Orchestrators - Provides a system that organizes and coordinates specialized AI agents through structured engineering workflows and verification checklists.
• Engineering Standardizations - Provides structured instructions and behavioral personas to standardize AI agent engineering tasks.
• Engineering Workflow Automation - Wraps specialized AI personas into repeatable commands for executing standardized engineering workflows.
• Workflow Intent Mappings - Translates natural language requests into specific technical sequences, such as mapping a bug report to a recovery workflow.
• Agent Configuration - Implements tools for defining and managing project-specific behavioral instructions for intelligent agents.
• Agent Persona Configurations - Uses dedicated markdown files to define the personality and behavioral traits of specialized AI personas.
• Agent Persona Frameworks - Uses specialized markdown-defined roles to shift agent behavior and expertise across different engineering domains.
• Agent Skill Extensions - Implements the installation and auto-discovery of standardized engineering instructions and commands for agents.
• Agent Skill Integrations - Integrates external tools and environment extensions to extend the capabilities of AI coding agents.
• Agent Skill Frameworks - Identifies the development phase and triggers the appropriate specialized skill set for the current task.
• Agent Skill Sets - Provides a curated library of engineering skills, such as TDD and debugging, to standardize agent behavior.
• Agentic Workflows - Provides frameworks for designing step-by-step actionable processes and verification checklists for autonomous agents.
• Iterative Refinement Workflows - Employs iterative refinement workflows to transform vague product ideas into concrete technical specifications.
• Role-Based Agent Orchestration - Coordinates agents by assigning specialized roles like security auditors or test engineers to complete complex tasks.
• Agent Configuration Standards - Defines project-wide guidelines and configuration standards to improve the technical accuracy of AI-generated code.
• Agent Persona Definitions - Defines specialized roles such as security auditors or test engineers to apply targeted expertise to specific tasks.
• Skill & Persona Definitions - Provides a collection of structured instructions and behavioral personas to standardize how AI agents perform engineering tasks.
• Agent Technical Specifications - Transforms vague product ideas into actionable technical specifications and verifiable task lists.
• AI Agent Skills - Matches developer intent to relevant skill definitions and loads appropriate workflows on-demand for engineering tasks.
• Context Filters - Selects specific source files and patterns relevant to a task to optimize the AI agent's context window.
• Context Window Optimizations - Implements strategies to optimize LLM token usage by dynamically loading and unloading skill sets.
• Instruction Set Packaging - Organizes domain expertise and global behavior constraints into portable instruction sets for agent loading.
• Specialist Personas - Creates role-specific system prompts for specialized tasks such as security auditing and performance analysis.
• Context Engineering - Organizes project information into a hierarchy of global rules, architecture specs, and transient outputs to optimize agent context.
• Recursive Task Decomposers - Decomposes high-level requirements into small, verifiable units with explicit acceptance criteria.
• Engineering Process Templates - Provides detailed step-by-step processes and verification checks to ensure agents complete engineering tasks correctly.
• Task Planning Systems - Generates lightweight execution plans to decompose complex objectives into actionable steps before modifying code.
• Multi-Axis Reviews - Conducts detailed code reviews across correctness, architecture, security, and performance axes.
• Agent Configurations - Provides local file-based settings to tailor AI agent behavior and operational rules for specific projects.
• Skill Discovery - Dynamically detects the appropriate engineering methodology and invokes the corresponding AI skill.
• Workflow - Triggers predefined workflows for planning, building, testing, or reviewing code via short-hand triggers.
• Vertical-Slice Decomposition - Organizes development tasks into end-to-end vertical slices to deliver functionality incrementally.
• Agentic Task Orchestration - Orchestrates parallel agent tasks to synthesize diverse expert findings into a consolidated report.
• Slash Command Interfaces - Provides a slash-command interface to trigger predefined workflows like TDD or performance audits.
• AI Engineering Workflows - Triggers structured sequences for specification, planning, implementation, and review via dedicated commands.
• Skill Definitions - Provides a structured system for defining modular agent capabilities and tasks through primary definitions and reference files.
• Command-Driven Sequences - Maps short text triggers to complex sequences of engineering skills to accelerate development tasks.
• AI Generation Verifications - Implements multi-axis review criteria and evidence-based verification steps to ensure AI-generated code meets production standards.
• Incremental Implementations - Orchestrates the building of features in thin vertical slices using TDD and source-grounded verification.
• AI Agent Security - Secures autonomous agents by treating LLM outputs as untrusted and restricting tool permissions.
• LLM Integration Audits - Evaluates LLM implementations for prompt injection and insecure output handling to prevent systemic compromise.
• LLM Security - Protects AI features by scoping tool permissions and managing LLM output as untrusted data.
• Architecture Decision Records - Implements a structured format for capturing the reasoning behind significant technical architectural decisions.
• Code Documentation Standards - Provides standardized instructions for explaining non-obvious logic and pitfalls within source code to prevent redundant decision-making.
• Simplification Patterns - Implements specialized logic to refactor complex code into cleaner, more readable patterns.
• Adversarial Design Reviews - Implements an adversarial review process to identify unstated assumptions and edge cases in non-trivial architectural changes.
• Documentation Grounding - Ensures technical accuracy by verifying code against official project versions and API documentation.
• Triage Workflows - Provides structured triage workflows to distinguish between code bugs and environment mismatches during failure analysis.
• Incremental Implementations - Provides a framework for implementing features via thin vertical slices and continuous verification.
• Intent-to-Skill Mappings - Translates natural language user requests into specific technical workflows by matching intent to predefined skill definitions.
• Onboarding Documentation - Defines structures for README files and convention guides to streamline onboarding for both humans and AI agents.
• Project Requirement Specifications - Provides a structured process for extracting detailed user requirements and defining project specifications.
• Software Requirements Analysis - Provides structured processes for transforming vague product ideas into actionable technical specifications.
• Implementation Planning - Translates technical specifications into sequenced execution strategies that identify risks, dependencies, and checkpoints.
• Test-Driven Development Loops - Implements a disciplined Red-Green-Refactor cycle by writing failing tests before producing functional code.
• Code Quality and Review - Performs multi-axis code reviews using severity labels and size limits to ensure production-grade software quality.
• Agentic Code Reviews - Conducts multi-axis reviews across correctness, readability, architecture, security, and performance dimensions.
• Evidence-Based Verifications - Implements a verification model requiring runtime data or passing tests as mandatory exit criteria for tasks.
• Functionality Verifiers - Implements structured processes to detect, localize, and resolve functional bugs in the codebase.
• Regression Proofing - Enforces a rigorous process of reproducing bugs with failing tests prior to implementation of fixes.
• Command-Driven Orchestrators - Provides a system for mapping short-hand triggers to structured engineering sequences and verification checklists.
• Agent Context Management - Organizes instructions into primary definitions and supporting reference files to optimize the agent context window.
• Session Initializers - Automatically bootstraps agent sessions by injecting required context and initializing workflows.
• Agent Skill Configurations - Supports structured definitions for agent skills that can be injected into global settings for cross-repository consistency.
• Manual Agent Invokers - Deploys targeted sub-agent definitions to perform domain-specific reviews and task delegations.
• Persona Assignments - Links specific identity profiles to agents to activate expert roles for targeted engineering reviews.
• Parallel Persona Coordinators - Runs multiple specialized personas concurrently to analyze a project and synthesize findings into a single report.
• Automated Change Summarization - Provides AI-driven workflows to generate structured reports of code changes for peer review.
• Document Grounding - Verifies coding decisions against official documentation and project-level configuration files to ensure technical accuracy.
• Conversation History Management - Manages conversation history by starting fresh sessions and summarizing progress to maintain focus in long sessions.
• Project Context Rules - Employs project-level configuration files to embed permanent context and rules that guide AI behavior across sessions.
• Multi-Agent Synthesis Systems - Fans out requests to multiple specialist personas and aggregates their independent findings into a single report.
• Planning Discipline Enforcers - Enforces implementation discipline by resisting over-engineering and unsolicited refactoring through structured checks.
• Change Sizing Strategies - Optimizes change sizing by splitting large modifications into focused and reviewable units.
• Dependency And Supply Chain - Maintains supply chain security via package updates, dependency reviews, and CI lockfile verification.
• Assistant Context Integrations - Fetches live data from database schemas and third-party documentation to enrich the agent's real-time context.
• Feature Flag Management - Provides mechanisms to control feature visibility through internal testing and canary releases using programmatic flag management.
• Dependency Mapping - Maps relationships between system components to determine optimal implementation order and avoid conflicts.
• Release Management - Standardizes the automation and versioning required to move code from development to production.
• Specification-Code Reconciliation - Identifies discrepancies between specifications and existing code to surface resolution options instead of making silent assumptions.
• Save-Point Patterns - Implements a save-point pattern by committing after every successful test increment.
• Workstream Management - Analyzes task dependencies to identify independent feature slices for simultaneous development.
• Automated Deployment Pipelines - Defines automated sequences for managing the flow of code from version control to production via CI/CD quality gates.
• Task Decomposers - Decomposes high-level technical specifications into small, verifiable tasks with explicit acceptance criteria.
• Automated Rollout Managers - Orchestrates deployment pipelines that move code through staging and production with integrated verification and monitoring.
• Production Readiness Checklists - Provides comprehensive checklists to verify code quality, security, and performance standards before production deployment.
• Deployment Rollbacks - Includes automated and manual sequences to revert failed deployments using feature flags or previous versions.
• Trunk-Based Versioning Workflows - Orchestrates trunk-based development and atomic commits to ensure safe and consistent production launches.
• Feature Flags - Defines methods for wrapping functionality in toggles to decouple code deployment from feature release.
• Review Feedback Classifiers - Labels code review feedback with severity levels like Critical or Nit to distinguish mandatory fixes.
• Resource-Level Access Controls - Verifies specific user permissions for resource modification to prevent broken access control.
• Agentic Process Guardrails - Prevents AI agents from skipping critical verification steps by pairing common rationalizations with factual rebuttals.
• Secrets Management - Prevents credential leaks into version control using pre-commit checks and strict ignore configurations.
• Security Auditing - Provides a specialized agent persona for analyzing code and infrastructure vulnerabilities with actionable remediation.
• Credential Leak Prevention - Prevents credential leaks by scanning staged changes for keys and utilizing ignore files for environment settings.
• Deployment Security Hardening - Prevents OWASP Top 10 vulnerabilities through integrated secret management and dependency auditing.
• Access Control - Validates authentication and ownership roles on protected endpoints to prevent unauthorized resource access.
• Threat Modeling - Utilizes STRIDE and OWASP standards to identify exploitable vulnerabilities and trust boundaries.
• Feature Flagged Migrations - Implements patterns for transitioning to new logic using feature flags and adapters to minimize regressions.
• Atomic Commit Automations - Standardizes the production of small, single-purpose commits to maintain high version control hygiene.
• Readability Refactorings - Provides capabilities to reduce structural complexity and improve codebase readability while preserving existing behavior.
• Coding Convention Specifications - Mandates compliance with team workflows and conventions by reading project-specific configuration files.
• Vertical Slicing - Organizes task decomposition by complete end-to-end user paths for incremental delivery.
• Engineering Standards - Implements a library of predefined skills for architectural patterns, TDD, and multi-axis reviews to ensure consistency.
• Feature Flags - Uses feature flags to isolate incomplete work and merge small increments without exposing unfinished features.
• Product Specification Refiners - Transforms vague concepts into actionable specifications by guiding users through brainstorming, stress-testing, and converging.
• On-Demand Context Loading - Allows for the explicit referencing of skill files within prompts to force specific workflows on-demand.
• Project Management - Automates the generation and maintenance of technical specifications and task lists as a source of truth.
• Production Launch Coordination - Implements structured workflows for coordinating staged rollouts and rollback procedures during production launches.
• Structured Bug Diagnosis - Employs a prove-it pattern to reproduce bugs with failing tests before implementing fixes.
• Technical Assumption Validation - Implements strategies to identify and resolve high-risk technical uncertainties before full-scale development.
• Technical Uncertainty Management - Surfaces assumptions and resolves conflicting requirements before implementation to prevent costly rework.
• Root Cause Analysis - Implements a systematic engineering process to reproduce and localize failures to identify root causes.
• Testing & Quality Assurance - Provides standardized instructions for writing automated tests using the Arrange-Act-Assert pattern.
• Test Strategy Design - Provides structured guidance for analyzing code interfaces to determine the appropriate level of testing.
• Test Coverage Metrics - Implements workflows to identify gaps in test suites and prioritize new tests to improve coverage.
• Deployment Rollbacks - Defines a triggered workflow to manually revert the production environment to a specific previous stable version.
• Agent Skills - Curated library of engineering workflow skills for coding assistants.
• Agentic Development Frameworks - Collection of specialized skills to extend agent functionality.
• AI Agents and Frameworks - Production-grade engineering skills for AI coding agents.
• AI Skills - Production-grade engineering skills for AI agents.

سجل النجوم