# James Moss - Using skills to pay the bills: graduating from solo hacks to a team workflow - DevCon26

## Executive summary

The talk addresses the challenge of 'skill sprawl'—the uncontrolled proliferation and management of AI coding agent skills within large organizations. While skills are powerful because they encode domain-specific logic into an agent's context, their current lack of standardized versioning, review, and centralized governance creates significant technical debt. The speaker advocates for treating skills as first-class software assets, requiring dedicated practices like decomposition, mandatory registries, automated reviews, and formal lifecycle management (CDLC) to ensure reliability and scalability.

## Key takeaways

- Manage Skill Sprawl with a Centralized Registry: Due to the low barrier to entry for creating skills, organizations face an 'insane amount' of them (2 million+ on GitHub alone). A centralized registry is crucial for visibility, preventing overlap, and ensuring all teams use approved versions. This also helps mitigate non-technical users needing access without requiring full developer seats.
- Adopt the Context Development Life Cycle (CDLC): Just as code requires a Software Development Lifecycle (SDLC), skills and context require their own CDLC. Practices like skill reviews, automated testing, and version control must be applied to maintain quality and prevent 'rot' (skills going out of sync with the codebase).
- Decompose Skills for Modularity: Instead of creating monolithic skills, break complex functionality into smaller, interconnected plugins. This allows agents to activate specific components and makes the skill set easier to maintain and debug.
- Enforce Governance via Registries: Using a registry provides a single source of truth, allowing organizations to enforce policies (e.g., 'approved skills only,' minimum release age) and integrate security scanning tools like Snyk.

## Technical details

- Skill Failure Modes: Key issues include: **Overlap** (multiple teams building the same thing in isolation), **Drift** (teams using older versions of skills when newer ones are available, e.g., 'Grill Me' vs. 'Grill with Docs'), **Rot** (skills becoming outdated relative to the codebase), and **Overloading** (too many skills in one repository, potentially causing agents to truncate descriptions and fail activation).
- The Agentic Equation: An agent's output is a function of the Model, the Harness, and the Context. Since changing the model or harness is difficult, optimizing the context (via skills and instructions) is identified as the most effective lever for improving agent performance.
- Skill Versioning and Scope: Skills must be version-controlled alongside the code they affect. Using local, non-repo-based skills ('global state') leads to 'works on my machine' problems because the agent's behavior depends on who is running it, creating a lack of audit trail.
- Dependency Management: The ideal solution for managing dependencies between skills (especially those not in the same package) involves mechanisms like 'peer dependencies' or, more futuristically, allowing the agent to infer necessary skills by reading them from the context.

## Practical implications

- Implement a dedicated 'Skills Registry' to centralize skill management and enforce version pinning.
- Establish CI/CD gates for skills, including automated linting and quality checks, mirroring code review processes.
- Mandate that all critical skills are checked into the repository (repo) rather than existing in local developer environments.
- Measure skill success using 'Evals' (evaluations), treating performance metrics as experiments to guide iterative improvements.

## Topics

AI Agents, Software Architecture, Dependency Management, DevOps/Build Engineering, Contextual Computing, Tessel, GitHub, Snyk, APM (Artifact Package Manager)

Source: https://www.youtube.com/watch?v=6VRKZQ3pmoU