# Using Agent Skills

> >-

- **Type:** Skill
- **Install:** `agentstack add skill-vanja-emichi-a0-agent-skills-using-agent-skills`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [vanja-emichi](https://agentstack.voostack.com/s/vanja-emichi)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [vanja-emichi](https://github.com/vanja-emichi)
- **Source:** https://github.com/vanja-emichi/a0_agent_skills/tree/main/skills/using-agent-skills

## Install

```sh
agentstack add skill-vanja-emichi-a0-agent-skills-using-agent-skills
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Using Agent Skills

> **Supporting files:** This skill has a companion orchestration patterns guide.
> Use `text_editor:read` with the full path shown in the file tree when this
> skill is loaded to open `orchestration-patterns.md` (sibling to this SKILL.md).

## Overview

This meta-skill helps you identify which skill to apply for a given task, and how to combine skills when a task spans multiple domains. Skills are not rigid scripts — they're behavioral frameworks that shape how the agent approaches a type of work.

**How to load a skill in Agent Zero:**
```
skills_tool:load skill_name=
```
Once loaded, the skill's instructions are active for the current session. You can load multiple skills and they compose together.

## The 20-Skill Taxonomy

### Planning & Specification

| Skill | When to Load |
|-------|-------------|
| `spec-driven-development` | Before building anything — turn requirements into a spec first |
| `planning-and-task-breakdown` | Decompose a large feature into a structured implementation plan |
| `idea-refine` | Explore and sharpen an underdeveloped idea before committing to it |

### Implementation

| Skill | When to Load |
|-------|-------------|
| `incremental-implementation` | Building features step by step with verification at each step |
| `test-driven-development` | Implementing with tests written first |
| `source-driven-development` | Before using any library/API that may have changed since training |

### Code Quality

| Skill | When to Load |
|-------|-------------|
| `code-review-and-quality` | Reviewing code before merging or shipping |
| `code-simplification` | Refactoring working code to be cleaner and easier to maintain |
| `debugging-and-error-recovery` | Diagnosing and fixing bugs or failing tests |

### Frontend & APIs

| Skill | When to Load |
|-------|-------------|
| `frontend-ui-engineering` | Building user interfaces with React/Tailwind |
| `api-and-interface-design` | Designing REST/GraphQL APIs or module interfaces |
| `browser-testing-with-devtools` | Testing UI in a real browser, inspecting DOM/console/network |

### Cross-Cutting Concerns

| Skill | When to Load |
|-------|-------------|
| `security-and-hardening` | Implementing auth, validation, secrets management |
| `performance-optimization` | Diagnosing and fixing performance issues |
| `context-engineering` | Setting up project guidance files, managing long sessions |

### Delivery & Operations

| Skill | When to Load |
|-------|-------------|
| `shipping-and-launch` | Pre-launch checklist, feature flags, staged rollouts |
| `git-workflow-and-versioning` | Commit messages, branching, PRs, semantic versioning |
| `ci-cd-and-automation` | CI/CD pipelines, GitHub Actions, Dockerfile |

### Documentation & Lifecycle

| Skill | When to Load |
|-------|-------------|
| `documentation-and-adrs` | READMEs, API docs, Architecture Decision Records |
| `deprecation-and-migration` | Removing APIs, database migrations, dependency upgrades |

## Skill Selection Flowchart

```
What is the task?
│
├── PLANNING
│   ├── I have an idea but it's not fully defined yet
│   │   └── → idea-refine
│   ├── I need to write a spec/requirements before coding
│   │   └── → spec-driven-development
│   └── I need to break a large feature into tasks
│       └── → planning-and-task-breakdown
│
├── IMPLEMENTATION
│   ├── Building a new feature from a spec
│   │   └── → incremental-implementation
│   │       (also load: test-driven-development if TDD)
│   ├── Using a library I'm not sure about
│   │   └── → source-driven-development (fetch docs first)
│   └── Writing tests for existing code
│       └── → test-driven-development
│
├── CODE QUALITY
│   ├── Reviewing code before merge
│   │   └── → code-review-and-quality
│   ├── Refactoring working code
│   │   └── → code-simplification
│   └── Something is broken / tests failing
│       └── → debugging-and-error-recovery
│
├── FRONTEND / API
│   ├── Building UI components or pages
│   │   └── → frontend-ui-engineering
│   │       (+ browser-testing-with-devtools for verification)
│   ├── Designing API endpoints or module interfaces
│   │   └── → api-and-interface-design
│   └── Debugging browser behavior / DOM / network
│       └── → browser-testing-with-devtools
│
├── CROSS-CUTTING CONCERNS
│   ├── Authentication, input validation, security headers
│   │   └── → security-and-hardening
│   ├── App is too slow / performance issues
│   │   └── → performance-optimization
│   └── Agent lacks project context / setting up guidance file
│       └── → context-engineering
│
├── DELIVERY
│   ├── About to deploy to production
│   │   └── → shipping-and-launch
│   ├── Writing commit messages / PRs / versioning
│   │   └── → git-workflow-and-versioning
│   └── Setting up or modifying CI/CD pipelines
│       └── → ci-cd-and-automation
│
└── DOCUMENTATION & LIFECYCLE
    ├── Writing README / ADRs / API docs
    │   └── → documentation-and-adrs
    └── Removing old APIs / database migrations / upgrades
        └── → deprecation-and-migration
```

## Multi-Skill Combinations

Many real tasks benefit from loading multiple skills. Common combinations:

### Feature Development (End-to-End)

```
1. spec-driven-development        → Write the spec
2. planning-and-task-breakdown    → Break into tasks
3. incremental-implementation     → Build step by step
4. test-driven-development        → Tests first
5. code-review-and-quality        → Review before merge
6. shipping-and-launch            → Deploy safely
```

### New Project Setup

```
1. context-engineering            → Write AGENTS.md
2. spec-driven-development        → Define what to build
3. api-and-interface-design       → Design the API layer
4. ci-cd-and-automation           → Set up the pipeline
5. documentation-and-adrs         → Initial ADRs
```

### Bug Investigation

```
1. debugging-and-error-recovery   → Systematic diagnosis
2. browser-testing-with-devtools  → Browser-side investigation
3. test-driven-development        → Regression test
4. git-workflow-and-versioning    → Clean fix commit
```

### Security Audit

```
1. security-and-hardening         → Run security checklist
2. code-review-and-quality        → Code-level review
3. documentation-and-adrs         → Record decisions
```

### Performance Investigation

```
1. performance-optimization       → Profile and fix
2. browser-testing-with-devtools  → Browser metrics
3. source-driven-development      → Verify library usage
```

## Core Operating Behaviors

These behaviors apply in every session, regardless of which skills are loaded:

### 1. Verify Before Assuming

Never assume code works. Run it. Test it. Check the actual output.

```
CHECK BEFORE CLAIMING SUCCESS:
→ Run the tests via code_execution_tool
→ Check the browser via browser tool (for UI)
→ Read the actual output, don't predict it
```

### 2. Understand Before Changing

Don't modify code you don't understand. Read it first.

```
BEFORE EDITING:
→ text_editor:read the file
→ grep -rn for usages (code_execution_tool)
→ git log to understand history
```

### 3. Scope Discipline

Do what was asked. Don't refactor unrelated code. Don't add unasked features.

```
FOR EVERY CHANGE ASK:
→ Was this asked for?
→ Is it required to complete the task?
→ If no to both — don't make it
```

### 4. Explicit Over Implicit

Make assumptions visible. State constraints. Document decisions.

```
MAKE THESE EXPLICIT:
→ What you're about to do and why
→ Trade-offs in your approach
→ What you're NOT doing and why
→ Decisions that future agents need to know
```

### 5. Trust the Source

When in doubt about an API, library, or framework — read the docs. Don't rely on memory.

```
→ Load source-driven-development for any external library
→ Use document_query or browser to fetch current docs
→ Verify before implementing
```

## How Skills Compose

Loaded skills modify agent behavior without overriding each other:

```
# Loading multiple skills composes their behaviors:
skills_tool:load skill_name=incremental-implementation
skills_tool:load skill_name=test-driven-development
skills_tool:load skill_name=security-and-hardening

# Now the agent:
# → Builds incrementally (incremental-implementation)
# → Writes tests first (test-driven-development)
# → Validates input at boundaries (security-and-hardening)
# All three behaviors are active simultaneously
```

When skills conflict (rare), the most recently loaded skill takes precedence for that specific behavior.

## Quick Reference: Load Commands

```bash
# Planning
skills_tool:load skill_name=idea-refine
skills_tool:load skill_name=spec-driven-development
skills_tool:load skill_name=planning-and-task-breakdown

# Implementation
skills_tool:load skill_name=incremental-implementation
skills_tool:load skill_name=test-driven-development
skills_tool:load skill_name=source-driven-development

# Quality
skills_tool:load skill_name=code-review-and-quality
skills_tool:load skill_name=code-simplification
skills_tool:load skill_name=debugging-and-error-recovery

# Frontend & API
skills_tool:load skill_name=frontend-ui-engineering
skills_tool:load skill_name=api-and-interface-design
skills_tool:load skill_name=browser-testing-with-devtools

# Cross-Cutting
skills_tool:load skill_name=security-and-hardening
skills_tool:load skill_name=performance-optimization
skills_tool:load skill_name=context-engineering

# Delivery
skills_tool:load skill_name=shipping-and-launch
skills_tool:load skill_name=git-workflow-and-versioning
skills_tool:load skill_name=ci-cd-and-automation

# Documentation & Lifecycle
skills_tool:load skill_name=documentation-and-adrs
skills_tool:load skill_name=deprecation-and-migration
```

## See Also

For advanced orchestration patterns — parallel skill execution, skill chaining, agent delegation templates — use `text_editor:read` on the `orchestration-patterns.md` file in this skill's directory (path shown in file tree when this skill is loaded).

## Red Flags

- Jumping into implementation without loading any skill
- Loading skills but not following their verification checklists
- Loading a skill then ignoring its Red Flags section
- Using a skill as a rigid checklist instead of a behavioral framework
- Not updating the task tracking file during long multi-skill sessions

## Verification

At any point in a session:

- [ ] The right skill(s) are loaded for the current task type
- [ ] Core Operating Behaviors are active (verify, understand, scope, explicit, source)
- [ ] Loaded skills' Red Flags sections have been checked
- [ ] Loaded skills' Verification checklists will be completed before marking done
- [ ] For complex tasks: a session tracking file exists at `/tmp/session-tasks.md`

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [vanja-emichi](https://github.com/vanja-emichi)
- **Source:** [vanja-emichi/a0_agent_skills](https://github.com/vanja-emichi/a0_agent_skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-vanja-emichi-a0-agent-skills-using-agent-skills
- Seller: https://agentstack.voostack.com/s/vanja-emichi
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.