home / skills / atrislabs / atris / meta

meta skill

safe

/atris/skills/meta

This skill helps you think before acting by checking maps, logs, and lessons to improve accuracy and alignment.

npx playbooks add skill atrislabs/atris --skill meta

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.6 KB

---
name: meta
description: Metacognition skill for AI agents. Use when starting work, feeling stuck, output feels off, or before complex tasks. Teaches how to think about thinking.
version: 1.0.0
tags:
  - meta
  - metacognition
---

# Meta Skill

How to be an effective agent. Load this when you need to check yourself.

## When to activate

- Starting a new session (orientation)
- Feeling stuck or uncertain
- Output feels sloppy or generic
- Complex task ahead
- After a mistake

## Context awareness

1. **MAP first** - Read `atris/MAP.md` before any search. It's the index.
2. **Journal context** - Check today's log for recent work, patterns, blockers.
3. **LESSONS.md** - What failed before? Don't repeat.
4. **Skill routing** - Frontend? Load `design`. Backend? Load `backend`. Writing? Load `writing`.

## Pace control

| Signal | Action |
|--------|--------|
| Simple task, clear path | Execute fast |
| Complex task, multiple approaches | Slow down, plan first |
| Uncertain about intent | Ask ONE question |
| Output feels off | Pause, re-read context |
| Stuck > 2 attempts | Escalate, don't spiral |

## Self-correction triggers

Stop and reassess when:
- You're about to search without checking MAP
- You're writing code during PLAN phase
- You're adding features not requested
- You're explaining instead of doing
- You've used words like "robust", "comprehensive", "streamlined"

## Memory leverage

Before acting:
1. Check `atris/policies/LESSONS.md` - short lessons from past mistakes
2. Check `atris/features/` - prior art for similar work
3. Check journal history - `grep -i "<keyword>" atris/logs/**/*.md`

## Skill composition

You can stack skills:
- `meta` + `design` = thoughtful frontend work
- `meta` + `backend` = careful API design
- `meta` + `writing` = deliberate prose

Meta is the foundation. Domain skills are the specialization.

## The loop

```
Orient (read context)
    ↓
Decide (which skill? what pace?)
    ↓
Act (execute with focus)
    ↓
Check (output match intent?)
    ↓
Learn (add to LESSONS if miss)
```

## Anti-patterns

- Grepping before MAP check
- Coding during planning
- Adding unrequested features
- Verbose explanations
- Guessing instead of asking
- Repeating past mistakes
- Creating skill without symlinking to .claude/skills/ (won't load mid-session)

## Skill evolution

Skills improve from your mistakes:
1. After REVIEW, log learnings to `LESSONS.md` (format: `date | skill | lesson`)
2. Repeated lessons (2-3x) get promoted into the relevant skill
3. Next agent loads the improved skill

You're training future agents. Leave the codebase smarter than you found it.

## One-liner

Think before you act. Check yourself. Use the system.

Overview

This skill teaches an agent to monitor and improve its own thinking. Use it to orient before work, recover when stuck, and ensure outputs match intent. It focuses on context checks, pacing, and disciplined self-correction.

How this skill works

The skill runs a short metacognitive checklist: read the index, review recent logs and lessons, choose an appropriate domain skill, then pick a pace and plan. It surfaces stop-triggers that force reassessment and suggests memory lookups to avoid repeating mistakes. Finally, it enforces a simple loop: Orient → Decide → Act → Check → Learn.

When to use it

Starting a new session or task orientation
When output feels vague, sloppy, or off-target
Facing a complex task with multiple approaches
After repeated failed attempts or a clear mistake
Before composing or routing to a domain-specific skill

Best practices

MAP-first: check the index before searching or coding
Journal check: scan recent logs and LESSONS for patterns and blockers
Plan before typing: avoid coding during the planning phase
Ask one clarifying question when intent is uncertain
Log concise lessons after review (date | skill | lesson)

Example use cases

Beginning a multi-step design sprint to choose the correct frontend skill pairing
Recovering from a stuck loop during API design by slowing and reorienting
Preparing to write a long technical doc by checking prior drafts and lessons
Escalating after two failed attempts on a task instead of repeating the same approach
Composing outputs that must avoid vague buzzwords and stick to requested scope

FAQ

What quick signals tell me to pause?

If output feels off, you’ve tried two approaches without success, you’re about to search without checking the index, or you notice you’re coding in the plan phase — pause and reassess.

How do I avoid repeating past mistakes?

Always scan LESSONS and recent journal entries before acting. grep prior work for keywords and apply those lessons to the current plan.

When should I stack this with another skill?

Load meta first for orientation, then combine: meta+design for careful frontend work, meta+backend for cautious API design, meta+writing for deliberate prose.