# Using Skills

> Use when a task could benefit from the skills library. Guides skill discovery, activation, composition, and effective application.

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

## Install

```sh
agentstack add skill-boparaiamrit-skills-by-amrit-using-skills
```

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

## About

# Using Skills

## Overview

Skills are not optional reading — they are mandatory workflows when their activation conditions are met.

**Core principle:** If a skill exists for your situation, you MUST use it. Not using it is a process violation.

## The Iron Law

```
IF A SKILL EXISTS FOR YOUR SITUATION, YOU MUST USE IT. NO EXCEPTIONS.
```

## When to Use

- Before starting any task (check if a skill applies)
- When composing multiple skills for complex work
- When unsure which skill applies

## When NOT to Use

This is a meta-skill. It's always relevant. Check it before every task.

## Anti-Shortcut Rules

```
YOU CANNOT:
- Skip checking for applicable skills — check before EVERY task
- Cherry-pick parts of a skill — follow it completely or not at all
- Say "I know the gist" and skip reading SKILL.md — read it fully every time
- Override Iron Laws with rationalizations — Iron Laws are absolute
- Skip a skill because "this task is simple" — simple tasks have applicable skills too
- Use a skill partially and claim you followed it — partial compliance ≠ compliance
- Deviate from a skill without documenting why and getting approval
```

## How Skills Work

### Automatic Activation

Skills activate when their `description` field matches the current situation:

```yaml
# In each SKILL.md:
description: "Use when debugging any technical issue..."
```

Before every task, check: **Does a skill exist for this?**

### Skill Composition

Skills compose naturally. A typical feature implementation activates:

```
brainstorming          → Understand requirements
    ↓
writing-plans          → Create implementation plan
    ↓
executing-plans        → Execute task by task
    ├── test-driven-development  → Per-task TDD cycle
    ├── verification-before-completion → After each task
    └── git-workflow             → Atomic commits
    ↓
code-review            → Review all changes
    ↓
verification-before-completion → Final verification
```

### Common Compositions

| Scenario | Skill Chain |
|----------|------------|
| New feature | brainstorming → writing-plans → executing-plans |
| Bug fix | systematic-debugging → test-driven-development → verification-before-completion |
| Full audit | codebase-mapping → architecture-audit + security-audit + performance-audit + database-audit |
| Refactoring | codebase-mapping → architecture-audit → refactoring-safely |
| Production incident | incident-response → systematic-debugging → test-driven-development |
| New API endpoint | brainstorming → api-design-audit → writing-plans → executing-plans |
| Frontend feature | brainstorming → frontend-audit → writing-plans → executing-plans |
| Deep quality check | product-completeness-audit → brutal-exhaustive-audit |
| API integration | full-stack-api-integration → verification-before-completion |
| Documentation | writing-documentation → code-review |
| Multi-role task | agent-team-coordination → (skills per role) |

## Skill Discovery

When starting a task:

```
1. READ the task description
2. IDENTIFY keywords that match skill descriptions
3. CHECK the entry point file activation table
4. IF match found → READ the SKILL.md before proceeding
5. IF multiple matches → compose them in logical order
6. IF no match → Proceed with general principles from core-principles.md
```

## Rules for Skill Usage

### Don't Skip Steps

Each skill's process is sequential and complete. Skipping steps means:
- You'll miss something
- You'll produce worse results
- You'll violate the iron law

### Don't Cherry-Pick

Using "the parts I like" from a skill is not using the skill. Follow it completely or not at all.

### Don't Override Iron Laws

Iron laws exist because violations cause real damage. No rationalization justifies breaking them.

### Do Compose Skills

Skills are designed to work together. When multiple skills apply, use all of them in the appropriate order.

### Do Report Deviations

If you need to deviate from a skill (rare), document why and get approval.

### Do Re-Read Skills

Even if you've used a skill before, re-read the SKILL.md each time. Skills get updated and your memory is imperfect.

## Quick Reference

| Need | Skill |
|------|-------|
| "I need to build something" | brainstorming → writing-plans → executing-plans |
| "Something is broken" | systematic-debugging |
| "Review this code" | code-review |
| "Is this done?" | verification-before-completion |
| "Audit the system" | codebase-mapping → [appropriate audit skills] |
| "Improve existing code" | refactoring-safely |
| "Production is down" | incident-response |
| "Write tests" | test-driven-development |
| "Document this" | writing-documentation |
| "Check security" | security-audit |
| "Why is it slow?" | performance-audit |
| "Check the database" | database-audit |
| "Check the frontend" | frontend-audit |
| "Design an API" | api-design-audit |
| "Check dependencies" | dependency-audit |
| "Check logging/monitoring" | observability-audit |
| "Check accessibility" | accessibility-audit |
| "Check CI/CD" | ci-cd-audit |
| "Git help" | git-workflow |
| "Check completeness" | product-completeness-audit |
| "Deep exhaustive audit" | brutal-exhaustive-audit |
| "Integrate an API" | full-stack-api-integration |
| "Multi-agent task" | agent-team-coordination |
| "Cross-session context" | persistent-memory |
| "Create a new skill" | writing-skills |

## Integration

- This is a meta-skill: used to discover and apply other skills
- Pairs with `writing-skills` for creating new skills
- References all other skills in the library

## Source & license

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

- **Author:** [boparaiamrit](https://github.com/boparaiamrit)
- **Source:** [boparaiamrit/skills-by-amrit](https://github.com/boparaiamrit/skills-by-amrit)
- **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-boparaiamrit-skills-by-amrit-using-skills
- Seller: https://agentstack.voostack.com/s/boparaiamrit
- 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%.