RLM Method Workflow

A comprehensive software development methodology that guides you through research, specification, implementation, and verification using structured prompts and documentation.

What This Skill Does

This skill implements the RLM (Research-Lead-Manage) v3.0.0 methodology, providing:

Instructions

Initial Setup

1. Always read these core files for context before any task:

- `AGENTS.md` — Universal agent instructions

- `RLM/START-HERE.md` — Workflow overview

- `RLM/specs/constitution.md` — Project standards and coding conventions

2. Configure auto-commits with semantic format:

- Format: `type(scope): description`

- Types: feat, fix, docs, refactor, test

- Reference RLM spec IDs when applicable (e.g., FTR-001, TASK-001)

Phase 1: Discovery & Research

When asked to "discover" or "research" an idea:

1. Read `RLM/prompts/01-DISCOVER.md` for the complete workflow

2. Check `RLM/research/project/` for existing research

3. Conduct 3-4 rounds of clarifying questions with the user

4. Generate PRD (Product Requirements Document) in `RLM/specs/`

5. Document research findings appropriately

Phase 2: Specification Creation

When asked to create specs from a PRD:

1. Read `RLM/prompts/02-CREATE-SPECS.md`

2. Generate feature specifications

3. Create architecture documentation

4. Break down into epic-level components

5. Save all specs to `RLM/specs/`

Phase 3: Task Creation

When asked to create tasks:

1. Read `RLM/prompts/03-CREATE-TASKS.md`

2. Break features into 1-4 hour tasks

3. Ensure each task is atomic and testable

4. Save tasks to `RLM/tasks/active/`

5. Link tasks to parent feature specs

Phase 4: Implementation (TDD 5-Step Process)

Follow this process for all implementation work:

**Step 1: Load Context (0-20%)**

**Step 2: Write Tests (20-40%)**

**Step 3: Implement (40-70%)**

**Step 4: Verify (70-85%)**

**Step 5: Review (85-100%)**

Phase 5: Design Specifications (UI/UX Work)

For design-related tasks:

1. Read `RLM/specs/PRD.md` for requirements

2. Create design system at `RLM/specs/design/design-system.md`

3. Define tokens at `RLM/specs/design/tokens.json`

4. For features: Create `design-spec.md` in feature directory

5. Ensure all components have 8 states:

- Default, Hover, Focus, Active, Disabled, Loading, Error, Empty

6. Follow WCAG 2.1 AA accessibility standards

Phase 6: Code Review

When performing code review:

1. Check for security vulnerabilities (OWASP Top 10)

2. Identify performance issues (N+1 queries, memory leaks, etc.)

3. Verify code quality and standards compliance

4. For UI code: Check design token usage and accessibility

5. Create review report at `RLM/progress/reviews/`

6. Block commit if critical issues are found

Phase 7: Verification

For end-to-end verification:

1. Run Playwright tests for the feature

2. Execute functional, accessibility, and visual tests

3. On PASS: Update status to "verified"

4. On FAIL: Create bug tasks in `RLM/tasks/active/`

5. Generate verification report at `RLM/progress/verification/`

Continuous Practices

Throughout all phases:

- TypeScript/JavaScript: `npx eslint --fix`

- Python: `ruff check --fix`

File Handling

Examples

Example 1: Starting a New Feature

```

User: "I want to add user authentication to the app"

1. Read RLM/prompts/01-DISCOVER.md

2. Ask clarifying questions about auth methods, providers, security requirements

3. Generate PRD.md with findings

4. Read RLM/prompts/02-CREATE-SPECS.md

5. Create feature spec, architecture docs, epic breakdown

6. Read RLM/prompts/03-CREATE-TASKS.md

7. Break into tasks like "Setup auth provider", "Create login UI", etc.

8. Save tasks to RLM/tasks/active/

```

Example 2: Implementing a Task

```

User: "Implement task TASK-042: Create login form component"

Load Context (0-20%):

Write Tests (20-40%):

Implement (40-70%):

Verify (70-85%):

Review (85-100%):

```

Example 3: Code Review

```

User: "Review the authentication feature"

1. Check security: password hashing, session management, CSRF protection

2. Check performance: query optimization, caching strategy

3. Verify standards: follows constitution.md conventions

4. Check accessibility: WCAG 2.1 AA compliance for login UI

5. Create RLM/progress/reviews/auth-feature-review.md

6. If critical issues found: block commit and create bug tasks

```

Constraints