# longtaskSkill

**Repository Path**: seeventh/longtask-skill

## Basic Information

- **Project Name**: longtaskSkill
- **Description**: long task skill for qwen code
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-03-06
- **Last Updated**: 2026-03-06

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Qwen Long-Task Skill

A comprehensive skill system for Qwen Code that transforms single-session AI coding into rigorous multi-session software engineering workflows with integrated bug analysis and resolution.

## Quick Start

### Installation

```bash
# Clone the skill
git clone https://github.com/your-org/qwen-long-task-skill.git ~/.qwen/skills/qwen-long-task

# Or copy to skills directory
cp -r qwen-long-task-skill ~/.qwen/skills/
```

### Usage

After installation, simply tell Qwen Code what you want to build:

```
> I want to build a REST API for a todo app. Use the long task skill.
```

Or for bug fixing:

```
> I have a bug in my authentication module. The error is "Token expired prematurely".
> Use the long task skill to analyze and fix it.
```

### Commands

| Command | Description |
|---------|-------------|
| `/lt` | Start or continue long-task workflow |
| `/lt:status` | Show current state |
| `/lt:reset` | Reset state (requires confirmation) |
| `/lt:req` | Start requirements collection |
| `/lt:design` | Start design phase |
| `/lt:init` | Initialize project |
| `/lt:work` | Start feature development |
| `/lt:bug` | Report a bug for analysis |
| `/lt:review` | Run code review |
| `/lt:st` | Run system testing |
| `/lt:quality` | Run quality gates |
| `/lt:tdd` | Start TDD cycle |

## Core Philosophy

### 1. Requirements-Driven Development
No code without understanding what to build. Every project starts with structured requirements collection.

### 2. Test-First Implementation
TDD (Red → Green → Refactor) for every feature. Quality gates ensure tests actually test something.

### 3. Systematic Bug Analysis
Bugs are analyzed with root cause tracing, not guess-and-fix. Every bug gets a regression test.

### 4. Persistent State
10+ artifacts bridge sessions automatically. No knowledge loss between conversations.

## Architecture

### Six-Phase Workflow

```
┌──────────────┐
│ REQUIREMENTS │ ← Structured requirements collection
└──────┬───────┘
       ↓
┌──────────────┐
│    DESIGN    │ ← Technical design with tradeoffs
└──────┬───────┘
       ↓
┌──────────────┐
│     INIT     │ ← Project scaffolding
└──────┬───────┘
       ↓
┌──────────────┐
│     WORK     │ ← Feature implementation (TDD + Quality)
└──────┬───────┘
       ↓
┌──────────────┐
│    REVIEW    │ ← Code review & compliance
└──────┬───────┘
       ↓
┌──────────────┐
│      ST      │ ← System testing
└──────────────┘

Bug Analysis can be invoked at any phase
```

### 10-Skill System

```
using-qwen-long-task (bootstrap router)
│
├─→ long-task-requirements ──→ long-task-design ──→ long-task-init
│                                                    │
├─→ long-task-bug-analysis (anytime)                 long-task-work
│                                                    │  │  │  │
│                                             ┌──────┘   │  └────┴──────────┐
│                                             ↓          ↓                  ↓
│                                        long-task  long-task         long-task
│                                          -tdd     -quality            -review
│                                             │           │
│                                             └───────────┴────────→ long-task-st
```

| Skill | Role |
|-------|------|
| `using-qwen-long-task` | Bootstrap router - detects state, invokes correct phase |
| `long-task-requirements` | Structured requirements collection → SRS |
| `long-task-design` | Technical design with tradeoff analysis |
| `long-task-init` | Project scaffolding and feature decomposition |
| `long-task-work` | Feature orchestrator (one feature per cycle) |
| `long-task-tdd` | TDD Red→Green→Refactor discipline |
| `long-task-quality` | Coverage + mutation testing gates |
| `long-task-bug-analysis` | Systematic bug analysis and resolution |
| `long-task-review` | Code review & spec compliance |
| `long-task-st` | System testing with Go/No-Go verdict |

## Persistent Artifacts

| File | Purpose |
|------|---------|
| `qwen-long-task-state.json` | Current phase, completed features, pending bugs |
| `feature-list.json` | Feature inventory with status tracking |
| `task-progress.md` | Session-by-session progress log |
| `docs/srs.md` | Software Requirements Specification |
| `docs/design.md` | Technical Design Document |
| `docs/bugs/*.md` | Bug analysis reports |
| `docs/test-cases/*.md` | Test case documents |
| `RELEASE_NOTES.md` | Living changelog |
| `.qwen-long-task/` | Skill configuration and cache |

## Quality Gates

Every feature must pass:

1. **TDD**: Tests written before implementation
2. **Coverage**: Line ≥90%, Branch ≥80%
3. **Mutation**: Score ≥80% (catches useless tests)
4. **Review**: Spec & design compliance check
5. **System Test**: Black-box acceptance testing

## Bug Analysis Workflow

When a bug is reported:

```
1. Collect Evidence
   ├─ Error messages & stack traces
   ├─ Reproduction steps
   ├─ Environment state
   └─ Recent changes (git diff)

2. Root Cause Analysis
   ├─ Trace error to source
   ├─ Identify failure pattern
   └─ Hypothesize causes

3. Write Regression Test
   ├─ Test that reproduces the bug
   └─ Must fail before fix

4. Fix Implementation
   ├─ Minimal targeted change
   └─ Run regression test

5. Verify & Prevent
   ├─ All tests pass
   ├─ No regressions
   └─ Document learnings
```

## Multi-Language Support

| Language | Test Framework | Coverage | Mutation |
|----------|---------------|----------|----------|
| Python | pytest | pytest-cov | mutmut |
| TypeScript | vitest/jest | c8/istanbul | Stryker |
| Java | JUnit | JaCoCo | PIT |
| Go | go test | built-in | gomu |
| Rust | cargo test | built-in | cargo-mutants |

## Project Structure

```
qwen-long-task/
├── skills/
│   ├── using-qwen-long-task/    # Bootstrap router
│   ├── long-task-requirements/  # Requirements collection
│   ├── long-task-design/        # Technical design
│   ├── long-task-init/          # Project initialization
│   ├── long-task-work/          # Feature orchestration
│   ├── long-task-tdd/           # TDD discipline
│   ├── long-task-quality/       # Quality gates
│   ├── long-task-bug-analysis/  # Bug analysis & fix
│   ├── long-task-review/        # Code review
│   └── long-task-st/            # System testing
├── scripts/
│   ├── get_tool_commands.py     # Map tech stack to commands
│   ├── check_configs.py         # Validate configurations
│   ├── validate_features.py     # Validate feature list
│   └── analyze-bug.py           # Bug analysis utilities
├── references/
│   ├── tdd-cycle.md             # TDD process guide
│   ├── bug-analysis.md          # Systematic debugging
│   ├── code-review.md           # Review checklist
│   └── quality-gates.md         # Gate definitions
├── templates/
│   ├── srs.md                   # Requirements template
│   ├── design.md                # Design template
│   ├── bug-report.md            # Bug report template
│   └── test-case.md             # Test case template
└── README.md
```

## Comparison: Typical AI vs Long-Task

| Capability | Typical AI | Long-Task |
|------------|-----------|-----------|
| Multi-session | Loses context | Persistent artifacts |
| Requirements | Code first | SRS before code |
| Testing | Optional | Mandatory TDD + gates |
| Bug fixing | Guess-and-fix | Systematic analysis |
| Code review | None | Automated compliance |
| Quality | Hope for best | Measured gates |

## Development Principles

1. **No code without tests** - Every feature has tests first
2. **No fix without reproduction** - Bugs must be reproducible
3. **No merge without review** - All changes reviewed
4. **No release without ST** - System testing required
5. **Measure twice, cut once** - Verify before claiming done

## License

MIT