pattern-awareness

Included with Lifetime

$97 forever

Use when building features in a codebase that has Fantasia maps (~/.claude/fantasia/<project>/codebase/). This skill teaches how to read and apply mapped patterns when writing new code.

Writing & Docs

What this skill does

You have access to codebase maps created by Fantasia. Use them to write code that fits naturally into this codebase.

## Fantasia Directory

Fantasia stores all outputs in the home directory to keep repos clean. The location can be customized via the `FANTASIA_DIR` environment variable.

```bash
# Calculate the Fantasia directory (or use env override)
if [ -z "$FANTASIA_DIR" ]; then
REPO_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
PROJECT_SLUG=$(basename "$REPO_ROOT" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
FANTASIA_DIR="$HOME/.claude/fantasia/$PROJECT_SLUG"
fi
```

All paths below use `$FANTASIA_DIR/codebase/` for maps.

## When to Use This

Use this skill when:
- You're writing new code and `$FANTASIA_DIR/codebase/` exists
- You need to understand project conventions
- You want to match existing patterns
- You're deciding how to structure new code

## How to Use the Maps

### Before Writing Code

1. **Check if maps exist**:
```bash
ls $FANTASIA_DIR/codebase/
```

2. **Read relevant maps** based on what you're doing:

| Task | Read These |
|------|------------|
| Any code change | CONVENTIONS.md |
| New component/service | ARCHITECTURE.md, STRUCTURE.md |
| External integration | INTEGRATIONS.md, STACK.md |
| Tests | TESTING.md |
| Fixing tech debt | CONCERNS.md |

### Applying Patterns

When you read a map file, look for:

1. **Naming conventions**: How things are named in this codebase
2. **File organization**: Where new code should live
3. **Error handling**: How errors are typically handled
4. **Logging**: How and when to log
5. **Type patterns**: How types/interfaces are defined
6. **Import style**: How imports are organized

### Example Workflow

```
User: Add a new UserPreferences service

You should:
1. Read ARCHITECTURE.md - understand service patterns
2. Read STRUCTURE.md - find where services live
3. Read CONVENTIONS.md - match naming/style
4. Find an existing service as reference
5. Write new code following the patterns
```

## Map File Reference

### STACK.md
Contains: Languages, frameworks, key dependencies
Use for: Understanding what tools/libraries to use

### ARCHITECTURE.md
Contains: System design, component responsibilities, data flow
Use for: Understanding where new code fits, how components interact

### STRUCTURE.md
Contains: Directory layout, file organization
Use for: Knowing where to put new files

### CONVENTIONS.md
Contains: Coding style, patterns, error handling
Use for: Matching code style exactly

### TESTING.md
Contains: Test framework, test organization, mocking patterns
Use for: Writing tests that match existing style

### INTEGRATIONS.md
Contains: External services, APIs, databases
Use for: Understanding how to connect to external systems

### CONCERNS.md
Contains: Technical debt, risks, improvement areas
Use for: Avoiding known issues, understanding fragile areas

## Important Rules

1. **Always read before writing**: Don't guess at patterns - read the maps
2. **Match exactly**: Your code should look like it was written by the same team
3. **Don't introduce new patterns**: Use what's already there unless asked to change
4. **Ask if unsure**: If maps don't cover your case, ask before inventing

Files: 1

Size: 3.4 KB

Complexity: 7/100

Category: Writing & Docs

Source: https://github.com/wannabefro/wanplugins/tree/main/fantasia/skills/pattern-awareness

Related in Writing & Docs

jax-development

Included

Use this skill when the user is writing, debugging, profiling, refactoring, reviewing, benchmarking, parallelising, exporting, or explaining JAX code, or when they mention JAX, jax.numpy, jit, grad, value_and_grad, vmap, scan, lax, random keys, pytrees, jax.Array, sharding, Mesh, PartitionSpec, NamedSharding, pmap, shard_map, Pallas, XLA, StableHLO, checkify, profiler, or the JAX repo. It helps turn NumPy or PyTorch-style code into pure functional JAX, fix tracer/control-flow/shape/PRNG bugs, remove recompiles and host-device syncs, choose transforms and sharding strategies, inspect jaxpr/lowering/IR, and benchmark compiled code correctly.

Writing & Docsscripts

nature-article-writer

Included

Drafts, rewrites, diagnostically critiques, and style-calibrates primary research manuscripts for Nature and Nature Portfolio journals. Use when the user wants a Nature-style title, summary paragraph or abstract, introduction, results, discussion, methods, figure legends, presubmission enquiry, cover letter, reviewer response, or when a scientific draft sounds generic, jargon-heavy, structurally weak, or AI-ish and needs precise, broad-reader-friendly prose without inventing data, analyses, or references. Best for primary research articles and letters rather than reviews or press releases unless explicitly adapting one.

Writing & Docsscripts

deckrd

Included

Document-driven framework that derives requirements, specifications, implementation plans, and executable tasks from goals through structured AI dialogue. Use when user says "write requirements", "create spec", "plan implementation", "derive tasks", "structure this feature", "break down into tasks", or "document this module". Also use for reverse engineering existing code into docs (/deckrd rev). Do NOT use for direct code writing — use /deckrd-coder after tasks are generated. Do NOT use when the user only wants to run or fix existing code without planning.

Writing & Docsscripts

clinical-decision-support

Included

Generate professional clinical decision support (CDS) documents for pharmaceutical and clinical research settings, including patient cohort analyses (biomarker-stratified with outcomes) and treatment recommendation reports (evidence-based guidelines with decision algorithms). Supports GRADE evidence grading, statistical analysis (hazard ratios, survival curves, waterfall plots), biomarker integration, and regulatory compliance. Outputs publication-ready LaTeX/PDF format optimized for drug development, clinical research, and evidence synthesis.

Writing & Docsscripts

handling-sf-data

Included

Salesforce data operations with 130-point scoring. Use this skill to create, update, delete, bulk import/export, generate test data, and clean up org records using sf CLI and anonymous Apex. TRIGGER when: user creates test data, performs bulk import/export, uses sf data CLI commands, needs data factory patterns for Apex tests, or needs to seed/clean records in a Salesforce org. DO NOT TRIGGER when: SOQL query writing only (use querying-soql), Apex test execution (use running-apex-tests), or metadata deployment (use deploying-metadata).

Writing & Docsscripts

accelint-ac-to-playwright

Included

Convert and validate acceptance criteria for Playwright test automation. Use when user asks to (1) review/evaluate/check if AC are ready for automation, (2) assess if AC can be converted as-is, (3) validate AC quality for Playwright, (4) turn AC into tests, (5) generate tests from acceptance criteria, (6) convert .md bullets or .feature Gherkin files to Playwright specs, (7) create test automation from requirements. Handles both bullet-style markdown and Gherkin syntax with JSON test plan generation and validation.

Writing & Docsscripts