# Development Rules

> Development workflow rules for task branching, phased execution, lint/format, testing, code review, and deployment. Trigger via /start.

- Skill: `lora-sys/development-rules` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add lora-sys/development-rules`
- Raw SKILL.md: https://api.skillmd.com/api/skills/lora-sys/development-rules/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: lora-sys (https://skillmd.com/u/lora-sys)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/lora-sys/development-rules

---


# Development Rules

Enforces a consistent development workflow for all tasks. Trigger via `/start`.

## Trigger

```
/start
```

## Task Type Judgment

Before anything else, determine the task type:

- **Web Development Task** — UI/frontend work, web pages, React/Next.js, etc.
- **Other Development Task** — backend, CLI, scripts, data engineering, etc.

## Unified Branch Flow

Regardless of task type, always follow this branch flow first:

1. If not on `main` branch → switch to `main`
2. Run `git pull` to fetch latest
3. Create a new feature branch for development
4. All work happens on the feature branch

## Phase 1: Feature Branch Setup

After branching, announce current node:

```
[Node 1/6] Branch setup complete — feature branch: <branch-name>
```

Then proceed to planning.

## Phase 2: Planning

Build a phased development plan:

- Break the task into clear, sequential phases
- Each phase should be independently testable
- For web dev tasks: call UI design skill / frontend design skill first
- For other dev tasks: call relevant domain skills

Announce the plan to the user for confirmation.

## Phase 3: Iterative Development

Loop through each phase:

```
[Node 2/6] Starting Phase N: <phase-name>
```

For each phase:

1. Complete phase functionality
2. Run lint and format checks
3. Run tests — **do not proceed if tests fail**
4. Announce phase completion

After all phases done:

```
[Node 3/6] All phases complete
```

## Phase 4: Code Review

For web dev tasks, call browser/MCP skills to test the application.

Then:

1. Call `/caveman-review` for code review
2. Fix all issues raised by the review
3. Commit the fixes

```
[Node 4/6] Code review complete — issues fixed and committed
```

## Phase 5: Integration Testing

1. Run E2E / integration tests
2. Run runtime analysis / performance checks
3. Fix any issues found
4. Commit fixes

```
[Node 5/6] Integration testing complete
```

## Phase 6: Push

```
[Node 6/6] Final push — all steps complete
```

1. Confirm all commits are in
2. Push the feature branch
3. Report summary to user

## Web Development Specific Steps

After planning, call these skills before coding:

- **UI Design Skill** — for visual/UX decisions
- **Frontend Design Skill** — for implementation approach

During testing (Phase 4), use browser MCP skills to:

- Open the app in browser
- Verify UI renders correctly
- Check console for errors
- Test interactive elements

## Behavioral Constraints

- **Do not skip steps** — follow the workflow in order
- **Announce every node** — user must know current execution point
- **Never skip lint, format, tests, or review**
- **Do not commit if tests fail**
- **Do not push if review issues are unfixed**
- **Stay on feature branch** — all work on the feature branch, not main
- **Keep the workflow repeatable** — same process every time

## Quick Reference

```
/start
  ├─ Judge task type (web / other)
  ├─ Branch flow (main → pull → feature branch)
  ├─ Planning (phased plan, call relevant skills)
  ├─ Iterative development (lint → format → test → commit per phase)
  ├─ Code review (caveman-review → fix → commit)
  ├─ Integration testing (E2E → runtime → fix → commit)
  └─ Push
```