# skills

**Repository Path**: auto-stack/skills

## Basic Information

- **Project Name**: skills
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-04-15
- **Last Updated**: 2026-05-14

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Claude Code Skills for Incremental Project Translation

A suite of three complementary skills for breaking down complex software projects and translating them to other languages incrementally.

## Skills Overview

### 1. `code-excerpter` — Extract Mini Programs

Extracts self-contained, compilable mini programs (50-200 lines each) from a larger codebase. Each mini program demonstrates one specific programming capability and can compile/run independently.

**Use when:** You need bite-sized test cases for language translation, or want to understand a codebase by studying its individual capabilities in isolation.

**Example output:** 33 standalone programs extracted from auto-code-rs, covering wrapping arithmetic, pattern matching, state machines, stream processing, REPL loops, etc.

### 2. `project-decomposer` — Progressive Snapshot Decomposition

Decomposes a complex project into a sequence of progressive snapshots — each a fully compilable, runnable project that builds incrementally on the previous one. Uses git history analysis + AI dependency inference (hybrid strategy).

**Use when:** You need a "start from scratch" reconstruction path for a project, or want to validate a transpiler against increasingly complex programs.

**Example output:** 6 snapshots of auto-code-rs, from minimal skeleton to full-featured AI coding agent.

### 3. `auto-lang-creator` — Auto Language Code Generator

Generates syntactically correct Auto language code. Provides Rust-to-Auto mapping, gotcha checklist, and code templates based on Auto Language Specification v0.2.

**Use when:** Writing, reviewing, or translating code to the Auto programming language.

## Recommended Workflow

```
┌─────────────────────────────────────────────────────┐
│  Complex Project (e.g., auto-code-rs in Rust)       │
└───────────┬─────────────────────────────────────────┘
            │
     Step 1: /code-excerpter
     Extract 20-40 standalone mini programs
     (each validates one language feature)
            │
            ▼
     Step 2: /auto-lang-creator
     Translate each mini program to Auto
     Fix issues iteratively, improve translator
            │
            ▼
     Step 3: /project-decomposer
     Generate 5-8 progressive project snapshots
     Translate each snapshot to Auto
     (validates project-level integration)
            │
            ▼
     Result: Full project translated & validated
```

**Key principle:** Start small, validate early, iterate fast.

## Skill Relationships

| Aspect | code-excerpter | project-decomposer | auto-lang-creator |
|--------|---------------|--------------------|--------------------|
| Granularity | Function-level (50-200 lines) | Module-level (full project) | File-level |
| Independence | Fully standalone | Each depends on previous | Per-file |
| Coverage | Key logic points | Entire codebase | Single translation unit |
| Best for | Single feature validation | Integration validation | Language translation |

## File Locations

```
~/.claude/skills/
  README.md                          ← This file
  README.cn.md                       ← Chinese version
  auto-lang-creator/
    skill.md                         ← Auto code generation rules
    references/auto-syntax.md        ← Auto language syntax reference
  code-excerpter/
    skill.md                         ← Mini program extraction process
    references/excerpt-patterns.md   ← 10 extraction pattern examples
  project-decomposer/
    skill.md                         ← Progressive snapshot process
    references/decomposition-patterns.md ← 5 decomposition pattern examples
```