A Day with LumenFlow

Software Delivery Pack workflow

This walkthrough uses the Software Delivery Pack — LumenFlow’s built-in pack for software development. The CLI commands (wu:claim, wu:prep, wu:done, gates) and concepts (WUs, lanes, worktrees) are all pack-provided tools that route through the kernel for governance.

This walkthrough follows a realistic day of development using LumenFlow, showing both AI-assisted and traditional developer workflows side by side.

Morning: Review and Plan

Check What’s Ready

AI-Assisted

# AI agent checks recent signals
pnpm mem:inbox --since 30m

# Review backlog
cat docs/operations/tasks/backlog.md

Traditional

# Developer checks the backlog
cat docs/operations/tasks/backlog.md

Pick a Work Unit

Today we’ll work on <wu-id>: “Add email validation to user signup”.

# docs/operations/tasks/wu/<wu-id>.yaml
id: <wu-id>
title: Add email validation to user signup
lane: 'Framework: Core'
status: ready
acceptance:
  - Email field validates format on blur
  - Invalid emails show error message
  - Valid emails allow form submission
  - Unit tests cover validation logic with 90% coverage
code_paths:
  - src/validation/email.ts
  - src/validation/__tests__/email.test.ts

Mid-Morning: Claim and Setup

Claim the WU

AI-Assisted

# Agent claims with full context
pnpm wu:claim --id <wu-id> --lane "Framework: Core"
cd worktrees/framework-core-<wu-id>

# Agent loads the canonical skills through its host's own mechanism
# tdd-workflow and code-quality

# Start agent session for memory tracking
pnpm agent:session --wu <wu-id> --tier 2

Traditional

# Developer claims the WU
pnpm wu:claim --id <wu-id> --lane "Framework: Core"

# IMMEDIATELY cd into the worktree
cd worktrees/framework-core-<wu-id>

# Verify you're in the right place
pwd
# /path/to/project/worktrees/framework-core-<wu-id>

Caution

Always cd into the worktree immediately after claiming. Working in the main checkout will cause hook failures and state inconsistencies.

Understand the Task

Review the acceptance criteria:

1. Email field validates format on blur - Need validation function
2. Invalid emails show error message - Need error handling
3. Valid emails allow form submission - Need success path
4. Unit tests cover validation logic - TDD approach

Late Morning: Test-First Development

Write Failing Tests (RED)

AI-Assisted

The AI agent follows TDD workflow skill and writes tests first:

// src/validation/__tests__/email.test.ts
import { describe, it, expect } from 'vitest';
import { validateEmail } from '../../validation/email';

describe('validateEmail', () => {
  it('should accept valid email formats', () => {
    expect(validateEmail('user@example.com').valid).toBe(true);
    expect(validateEmail('user.name@domain.co.uk').valid).toBe(true);
    expect(validateEmail('user+tag@example.com').valid).toBe(true);
  });

  it('should reject invalid email formats', () => {
    expect(validateEmail('invalid').valid).toBe(false);
    expect(validateEmail('missing@domain').valid).toBe(false);
    expect(validateEmail('@nodomain.com').valid).toBe(false);
    expect(validateEmail('spaces in@email.com').valid).toBe(false);
  });

  it('should return error message for invalid emails', () => {
    const result = validateEmail('invalid');
    expect(result.valid).toBe(false);
    expect(result.error).toBe('Please enter a valid email address');
  });

  it('should handle edge cases', () => {
    expect(validateEmail('').valid).toBe(false);
    expect(validateEmail('   ').valid).toBe(false);
  });
});

Traditional

Developer creates test file first:

# Create test file
mkdir -p src/validation/__tests__
touch src/validation/__tests__/email.test.ts

Then writes tests covering all acceptance criteria.

Verify Tests Fail

pnpm test --filter my-app
# Expected: 4 tests fail (module not found)

Tip

This confirms our tests actually test something. If tests pass before implementation, they’re not testing the right thing.

Early Afternoon: Implementation (GREEN)

Write Minimal Implementation

AI-Assisted

Agent implements just enough to pass tests:

// src/validation/email.ts
export interface EmailValidationResult {
  valid: boolean;
  error?: string;
}

const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

export function validateEmail(email: string): EmailValidationResult {
  const trimmed = email.trim();

  if (!trimmed) {
    return { valid: false, error: 'Please enter a valid email address' };
  }

  if (!EMAIL_REGEX.test(trimmed)) {
    return { valid: false, error: 'Please enter a valid email address' };
  }

  return { valid: true };
}

Traditional

Developer creates implementation file:

mkdir -p src/validation
touch src/validation/email.ts

Then writes the validation function.

Verify Tests Pass

pnpm test --filter my-app
# Expected: 4 tests pass

Check Coverage

pnpm test --filter my-app -- --coverage
# Verify >= 90% coverage on new code

Mid-Afternoon: Refactor and Polish

Refactor (Keep Tests Green)

AI-Assisted

Agent improves code quality while keeping tests green:

// src/validation/email.ts

// Extract constants
const VALIDATION_MESSAGES = {
  INVALID_EMAIL: 'Please enter a valid email address',
} as const;

// More robust regex from established library pattern
const EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

export interface EmailValidationResult {
  valid: boolean;
  error?: string;
}

export function validateEmail(email: string): EmailValidationResult {
  const trimmed = email.trim();

  if (!trimmed || !EMAIL_REGEX.test(trimmed)) {
    return {
      valid: false,
      error: VALIDATION_MESSAGES.INVALID_EMAIL,
    };
  }

  return { valid: true };
}

Traditional

Developer refactors:

• Extract magic strings to constants
• Improve regex pattern
• Add JSDoc comments
• Run tests after each change

Run Tests Again

pnpm test --filter my-app
# All tests still pass

Early Afternoon: Quick Docs WU (Parallel)

While the core work is stable, we knock out a small documentation WU in parallel.

# Claim a docs WU
pnpm wu:claim --id <wu-id> --lane "Content: Documentation"
pnpm wu:brief --id <wu-id> --client <client>
cd worktrees/content-documentation-<wu-id>

# Make doc edits...

# Run docs-only gates
pnpm wu:prep --id <wu-id> --docs-only

# Complete from main
cd /path/to/main
pnpm wu:done --id <wu-id>

Late Afternoon: Gates and Completion

Run Quality Gates

AI-Assisted

# Agent runs gates in worktree
pnpm wu:prep --id <wu-id>

# Output:
# [wu-prep] Running format check...
# [wu-prep] Running lint...
# [wu-prep] Running typecheck...
# [wu-prep] Running tests...
# [wu-prep] Gates passed

Traditional

# Developer runs gates
pnpm wu:prep --id <wu-id>

# If format fails:
pnpm format
# Then re-run wu:prep

Commit Changes

# Stage changes
git add src/validation/

# Commit with WU reference
git commit -m "wu(<wu-id>): add email validation with tests

- Add validateEmail function with format validation
- Return error messages for invalid inputs
- 100% test coverage on validation logic"

Complete the WU

AI-Assisted

# Agent signals completion
pnpm mem:signal "Implementation complete, gates passing" --wu <wu-id>

# Return to main and complete
cd /path/to/project
pnpm wu:done --id <wu-id>

# Output:
# [wu:done] Merging to main (fast-forward)...
# [wu:done] Creating stamp...
# [wu:done] Cleaning up worktree...
# [wu:done] <wu-id> completed successfully

Traditional

# Return to main checkout
cd /path/to/project

# Complete the WU
pnpm wu:done --id <wu-id>

# This:
# 1. Requires a successful wu:prep
# 2. Fast-forward merges to main
# 3. Creates .lumenflow/stamps/<wu-id>.done
# 4. Updates backlog.md and status.md
# 5. Removes the worktree

Caution

Run wu:prep from the worktree, then run wu:done from the main checkout.

End of Day: Review

Check Completion

# Verify stamp exists
ls .lumenflow/stamps/<wu-id>.done

# Check git log
git log --oneline -3
# abc1234 wu(<wu-id>): done - add email validation
# def5678 wu(<wu-id>): claim for framework-core lane
# ...

Update Memory (AI-Assisted)

# End agent session
pnpm agent:session-end

# Create checkpoint for context recovery
pnpm mem:checkpoint --wu <wu-id>

Complete Timeline

Time	Activity	Commands
9:00	Review backlog	cat docs/operations/tasks/backlog.md
9:15	Claim <wu-id>	pnpm wu:claim --id <wu-id>
9:20	cd to worktree	cd worktrees/framework-core-<wu-id>
10:00	Write failing tests	TDD RED phase
10:30	Run tests (fail)	pnpm test
11:00	Implement feature	TDD GREEN phase
11:30	Run tests (pass)	pnpm test
12:30	Claim docs <wu-id>	pnpm wu:claim --id <wu-id> --lane "Content: Documentation"
13:00	Docs gates	pnpm wu:prep --id <wu-id> --docs-only
13:15	Complete <wu-id>	pnpm wu:done --id <wu-id>
14:00	Refactor	TDD REFACTOR phase
14:30	Check coverage	pnpm test -- --coverage
15:00	Run gates	pnpm wu:prep --id <wu-id>
15:30	Commit changes	git commit
16:00	Complete <wu-id>	pnpm wu:done --id <wu-id>

Common Issues

”Gates failing on format"

pnpm format
git add -A
git commit --amend --no-edit
pnpm wu:prep --id <wu-id>

"Working in wrong directory”

If you made changes in main instead of worktree:

# Check where changes are
git status

# If in main, move changes into the worktree and commit there
git diff > /tmp/main-changes.patch
git diff --name-only > /tmp/main-changed-paths.txt
cd worktrees/framework-core-<wu-id>
git apply /tmp/main-changes.patch
git add .
git commit -m "wu(<wu-id>): implement feature"

# Restore only the paths you just moved on main — never the whole tree
cd /path/to/main
git restore $(cat /tmp/main-changed-paths.txt)

“wu:done from worktree”

ERROR: WRONG_LOCATION - wu:done must be run from main checkout

FIX: pnpm -C /path/to/project wu:done --id <wu-id>

Key Takeaways

Claim then cd

Always cd into the worktree immediately after claiming.

Test first

Write failing tests before implementation (RED-GREEN-REFACTOR).

Gates before done

Run pnpm wu:prep --id WU-XXX in the worktree before wu:done.

Complete from main

Run pnpm wu:done from the main checkout, not the worktree.

Next Steps

• Solo Developer Workflow - Simplified flow for individual work
• Team Workflow - Coordinating with teammates
• AI Agent Integration - Deep dive on AI workflows
• Troubleshooting - Common issues and solutions