In the rapidly evolving landscape of AI-driven development, software engineers are increasingly turning to intelligent agents to automate mundane, repetitive tasks. However, a persistent challenge remains: the institutional knowledge required to execute these tasks effectively often stays locked within individual chat sessions or confined to the minds of a few senior team members. To address this, developers are shifting toward "agent skills"—a framework designed to codify repeatable instructions into reusable, versioned files that teams can maintain, review, and deploy across diverse agent environments.
The concept, highlighted by Andrea Griffiths, a Senior Developer Advocate at GitHub, during a session at GitHub Universe 2026, aims to solve the "re-explanation" problem. Every time a developer has to explain the same complex task to an AI agent, efficiency is lost. When that knowledge is codified as a skill, the instruction becomes a durable asset, moving from a temporary chat prompt to a permanent part of a team’s engineering pipeline. By capturing the logic behind a task in a structured format, developers ensure that context is preserved rather than discarded, enabling both individual developers and their teams to scale their workflows.
Defining the Role of Agent Skills
An agent skill is essentially a versioned directory centered on a SKILL.md file. This file serves as the definitive guide for when and how to perform a specific task. While these instructions are portable and can be shared across different agents, the underlying environment remains the ultimate arbiter of capability. A skill may define the logic for querying a database or executing a security scan, but it does not inherently grant the permissions to do so. The separation of concerns is vital: the skill provides the "how-to," while the host environment provides the tools, credentials, and security permissions necessary to carry out the work.
This modular approach ensures that while judgment is shared, access is controlled. For instance, in the "Proof Agent" demo presented at GitHub Universe, the skill is tasked with the adversarial verification of AI-generated work. In this workflow, a separate, independent verifier is spawned to scrutinize changes for false claims, security vulnerabilities, or broken code. The core philosophy here is that self-verification is not true verification; an agent should not be the sole judge of its own output. By defining this in a SKILL.md file, the task becomes a reusable standard that can be applied to any piece of code generated by an AI assistant.
Coordinating Complex Workflows
Many data engineering pipelines suffer from fragmented knowledge, where the logic for a pipeline is held by several different people across an organization. When those individuals are unavailable, progress stalls. Projects like "Data Forge" demonstrate how multiple, specialized skills can be coordinated to create a cohesive, automated workflow.
In a typical support-desk pipeline scenario, the process begins with a request for specific metrics. Instead of relying on manual intervention, the forge-init skill is deployed to discover relevant information—such as source tables and naming conventions—and record it into a resolved manifest. This manifest acts as a shared source of truth, allowing subsequent skills to perform their functions without needing to rediscover context.
The forge-builder skill then coordinates the broader task, delegating specific sub-tasks to other tools. It might call upon forge-dbx to handle queries against a data platform, or forge-lint to ensure that the code adheres to established team standards. Because each skill has a strictly defined responsibility, the workflow becomes highly maintainable. If a team’s standard for linting changes, only the forge-lint skill needs to be updated; the rest of the pipeline remains untouched. This level of abstraction allows teams to handle bounded, repeatable work—such as migrations, checklists, and metric pipelines—with a consistency that was previously difficult to achieve.

Separating Configuration from Logic
A common pitfall in automation is hardcoding project-specific details directly into the logic of a script or agent. To avoid this, successful agent skills rely on a clear separation between the instruction set and the project configuration. By using a manifest file, developers can store project-specific parameters like database names, platform engines, and framework preferences.
This architecture ensures that skills remain portable. A forge-dbx skill, for example, can be configured to select either a Databricks or a DuckDB adapter based on the information provided in the manifest. The skill does not need to know the specifics of the environment, nor does it attempt to handle infrastructure tasks like installing CLI tools or managing database credentials. Those responsibilities remain firmly within the domain of the host environment and the user. This design choice is a litmus test for portability: if a team can take a set of skills and apply them to their own manifest without rewriting the core logic, the skills are truly modular.
Implementing Checks and Balances
The integration of human judgment remains a critical component of any automated workflow. In the Data Forge support-desk example, the workflow is broken down into seven distinct phases, each requiring a human checkpoint before moving to the next. This ensures that the agent serves as an assistant rather than an autonomous actor capable of making high-stakes decisions without oversight.
Similarly, the Proof Agent example demonstrates how to integrate verification into a CI/CD process. By providing a verifier with the original request and the proposed code changes, the system can return a "Pass," "Fail," or "Partial" result. By default, a "Fail" result blocks a pull request, forcing human intervention. This approach keeps the burden of proof and merge requirements within the repository’s existing CI checks and rules, rather than delegating them to the agent’s internal reasoning.
Packaging for Diverse Environments
As organizations adopt a variety of AI tools—such as Claude Code, Cursor, or GitHub Copilot—maintaining parity between agent environments becomes a significant challenge. To manage this, developers can use a centralized repository of skills that are packaged for specific clients. A packaging script can generate client-specific configurations, such as .claude-plugin/plugin.json or .github/agents/*.agent.md, from a single source of truth.
This packaging process is not merely about format conversion; it is an opportunity to verify that each client environment is correctly configured to support the skill. After installation, developers should confirm that the client recognizes the skill, can successfully load its references, and has access to the required tools to provide the necessary evidence.
Ultimately, the transition toward agent skills is about reclaiming time and reducing cognitive load. By identifying the tasks that are most frequently explained to colleagues or AI agents, developers can begin the process of formalizing those workflows. Starting with a clear definition of a job, its inputs, and its desired outputs allows teams to move away from ad-hoc, ephemeral solutions toward a more robust, standardized approach to engineering. As these practices mature, the role of the developer evolves from manually executing repetitive tasks to architecting the intelligent systems that perform them, ensuring that institutional knowledge is preserved and effectively leveraged across the entire organization.

