Agent workflow was overly complex with separate describe+new steps.
Using jj commit achieves the same result in one command.

Assisted-by: Claude Opus 4.5 via Claude Code

diff --git a/ai/claude/skills/coordinating-subagents-with-jj-workspaces/SKILL.md b/ai/claude/skills/coordinating-subagents-with-jj-workspaces/SKILL.md
index bfe50df8..d90bfb27 100644
--- a/ai/claude/skills/coordinating-subagents-with-jj-workspaces/SKILL.md
+++ b/ai/claude/skills/coordinating-subagents-with-jj-workspaces/SKILL.md
@@ -44,8 +44,7 @@ Enable safe parallel feature development by dispatching independent subagents to
 
 - [ ] Agent makes file edits in workspace
 - [ ] Agent runs verification (tests, type checks)
-- [ ] Agent describes change: `jj describe -m "..."`
-- [ ] Agent creates new change: `jj new -A @ -B mm`
+- [ ] Agent commits change: `jj commit -m "..."`
 - [ ] Agent reports completion with results and change ID
 
 ### Phase 4: Review (Coordinator)
@@ -144,19 +143,15 @@ Task 3: Dispatch DB agent to db workspace
 1. Work ONLY in their assigned workspace path
 2. Make file edits to implement the task
 3. Run verification steps (tests, type checks, etc.)
-4. Describe the change: `jj describe -m "feat: ..."` (use describing-changes skill)
-5. Create new change: `jj new -A @ -B mm`
-6. Report results: what changed, verification output, final change ID
+4. Commit the change: `jj commit -m "feat: ..."` (use describing-changes skill)
+5. Report results: what changed, verification output, final change ID
 7. Make NO changes outside their workspace
 
 **Agent workflow:**
 1. Make file edits in workspace
 2. Run verification commands
-3. Describe changes with `jj describe -m "..."`
-4. Create new change with `jj new -A @ -B mm`
-5. Report completion with results and change ID
-
-This inserts a new empty change between the completed work and the workspace's stable parent, ready for the next task.
+3. Commit changes with `jj commit -m "..."`
+4. Report completion with results and change ID
 
 **FORBIDDEN for agents:**
 - `jj workspace` commands - breaks isolation
@@ -203,8 +198,7 @@ jj status
 | Mistake | Fix |
 |---------|-----|
 | Skipping DAG placement | Must run `jj rebase -r <ws>@ -A 'trunk()' -B mm` after creating workspace |
-| Agent skipping `jj describe` | Agent must describe their changes before creating new change |
-| Agent skipping `jj new` | Agent must run `jj new -A @ -B mm` after describing |
+| Agent skipping `jj commit` | Agent must commit their changes with `jj commit -m "..."` |
 | Skipping `jj workspace update-stale` | Run in main workspace after agent completes to sync and detect conflicts |
 | Creating workspaces during dispatch | Create all workspaces and place in DAG BEFORE dispatch |
 | Agent touching other workspaces | Agents work ONLY in their assigned workspace path |
@@ -217,8 +211,7 @@ If you catch yourself thinking ANY of these, you're about to violate the workflo
 | Red Flag | Reality |
 |----------|---------|
 | "I'll skip DAG placement" | NO. Must insert workspace between trunk and mm for clean integration. |
-| "Agent doesn't need to describe" | NO. Agent must run `jj describe` to document the change. |
-| "Agent doesn't need jj new" | NO. Agent must run `jj new -A @ -B mm` after describing. |
+| "Agent doesn't need to commit" | NO. Agent must run `jj commit` to finalize the change. |
 | "I'll create workspaces during dispatch" | Create ALL workspaces and place in DAG first. |
 | "I'll skip `jj workspace update-stale`" | Run after agent completes. This syncs main workspace. |
 | "I'll create a custom directory" | NO. Always use `~/src/workspaces/`. No exceptions. |
diff --git a/ai/claude/skills/jj-workspace-experiments/SKILL.md b/ai/claude/skills/jj-workspace-experiments/SKILL.md
new file mode 100644
index 00000000..503c667d
--- /dev/null
+++ b/ai/claude/skills/jj-workspace-experiments/SKILL.md
@@ -0,0 +1,302 @@
+---
+name: jj-workspace-experiments
+description: Create isolated jj workspaces for testing changes, running experiments in parallel, and exploring alternative implementations. Use when testing breaking changes, comparing different approaches, or running long-running operations without blocking other work. (project)
+source: https://github.com/thoughtpolice/a/blob/canon/.claude/skills/jj-workspace-experiments/SKILL.md
+---
+
+# Jj Workspace Experiments
+
+## Overview
+
+Create isolated jj workspaces in the `work/` directory to test changes, run experiments concurrently, and explore alternative implementations without affecting the main workspace. All workspaces share the same repository history, enabling seamless switching and comparison between approaches.
+
+## When to Use
+
+Use this skill when:
+- Testing breaking changes or refactors that might not work
+- Comparing multiple implementation approaches side-by-side
+- Running long-running tests or builds without blocking other work
+- Exploring alternative solutions to a problem concurrently
+- Testing changes that require extensive experimentation
+- Working on multiple independent features simultaneously
+
+## Core Workflows
+
+### Single Experiment Workspace
+
+Create a workspace to test changes in isolation.
+
+#### 1. Create the Workspace
+
+```bash
+jj workspace add --name=<experiment-name> work/<directory-name>
+```
+
+**Examples:**
+```bash
+# Test a refactoring
+jj workspace add --name=async-refactor work/async-refactor
+
+# Try a different architecture
+jj workspace add --name=new-db-layer work/new-db-layer
+
+# Experiment with a breaking change
+jj workspace add --name=api-v2 work/api-v2
+```
+
+The workspace starts from the current commit (`@`) by default. To start from a different commit:
+
+```bash
+jj workspace add --name=<name> -r <revision> work/<directory>
+```
+
+#### 2. Work in the Workspace
+
+Navigate to the workspace and make changes:
+
+```bash
+cd work/<directory-name>
+
+# Make changes, run tests, build
+# Commits created here are isolated to this workspace
+```
+
+Changes are visible from the main workspace via `jj log` - all workspaces share the repository history.
+
+#### 3. Evaluate and Decide
+
+After testing:
+
+**If successful:** Merge the changes back to the main branch:
+```bash
+# From main workspace
+jj rebase -s <experiment-name>@ -d @
+```
+
+**If unsuccessful:** Simply forget the workspace:
+```bash
+jj workspace forget <experiment-name>
+rm -rf work/<directory-name>
+```
+
+The commits remain in the repository history but can be abandoned if needed.
+
+### Parallel Experiments
+
+Test multiple approaches simultaneously by creating multiple workspaces.
+
+#### 1. Create Multiple Workspaces
+
+```bash
+# Create first approach workspace
+jj workspace add --name=approach-a work/approach-a
+
+# Create second approach workspace
+jj workspace add --name=approach-b work/approach-b
+
+# Create third approach workspace (optional)
+jj workspace add --name=approach-c work/approach-c
+```
+
+Each workspace starts from the same commit, creating parallel branches of development.
+
+#### 2. Implement Different Approaches
+
+Work in each workspace independently:
+
+```bash
+# Terminal 1: Implement approach A
+cd work/approach-a
+# Make changes...
+
+# Terminal 2: Implement approach B
+cd work/approach-b
+# Make changes...
+
+# Terminal 3: Implement approach C
+cd work/approach-c
+# Make changes...
+```
+
+#### 3. Compare Results
+
+From the main workspace, compare implementations:
+
+```bash
+# View all workspace changes
+jj log -r 'working_copies()'
+
+# Compare approach A to approach B
+jj diff -r approach-a@ -r approach-b@
+
+# View specific workspace state
+jj show approach-a@
+```
+
+#### 4. Choose Winner and Clean Up
+
+Select the best approach and merge it:
+
+```bash
+# Merge winning approach
+jj rebase -s approach-b@ -d @
+
+# Forget the other workspaces
+jj workspace forget approach-a
+jj workspace forget approach-c
+
+# Clean up directories
+rm -rf work/approach-a work/approach-c
+```
+
+### Long-Running Operations
+
+Use a workspace to run long builds/tests without blocking other work.
+
+#### 1. Create Workspace for Long Operation
+
+```bash
+jj workspace add --name=test-run work/test-run
+```
+
+#### 2. Start Long Operation
+
+```bash
+cd work/test-run
+
+# Start long-running operation
+buck2 test //... &
+```
+
+#### 3. Continue Work Elsewhere
+
+While the operation runs, work normally in the main workspace:
+
+```bash
+cd $REPO_ROOT  # Back to main workspace
+# Continue development normally
+```
+
+#### 4. Check Results When Ready
+
+Return to the test workspace to check results:
+
+```bash
+cd work/test-run
+# Check test results, build artifacts, etc.
+```
+
+## Advanced Patterns
+
+### Testing Changes on Different Base Commits
+
+Create workspaces from different commits to test compatibility:
+
+```bash
+# Test on current commit
+jj workspace add --name=current-test work/current-test
+
+# Test on older commit
+jj workspace add --name=backport-test -r @-- work/backport-test
+
+# Test on main branch
+jj workspace add --name=main-test -r main work/main-test
+```
+
+### Darcs-Style Multiple Workspaces
+
+Create a sparse main workspace with all real work in sub-workspaces:
+
+```bash
+# Make main workspace sparse (only work/ directory)
+jj sparse set --clear --add work
+
+# Create multiple workspaces for different tasks
+jj workspace add work/feature-a
+jj workspace add work/feature-b
+jj workspace add work/bugfix-123
+```
+
+Now the main workspace is empty, but `work/` contains multiple full checkouts that all share the repository history.
+
+### Workspace as Scratch Space
+
+Create temporary workspaces for quick experiments:
+
+```bash
+# Create scratch workspace
+jj workspace add --name=scratch work/scratch
+
+cd work/scratch
+# Experiment freely without concern
+
+# When done, forget it
+jj workspace forget scratch
+rm -rf work/scratch
+```
+
+## Best Practices
+
+### Naming Conventions
+
+Use descriptive names that indicate purpose:
+- **Experiments:** `sqlite-vs-postgres`, `algorithm-a`, `refactor-v2`
+- **Features:** `feature-auth`, `feature-search`
+- **Tests:** `test-integration`, `perf-benchmark`
+- **Scratch:** `scratch`, `temp-experiment`
+
+### Workspace Lifecycle
+
+1. **Create** workspace with clear purpose
+2. **Work** in isolation until complete or failed
+3. **Evaluate** results and make decision
+4. **Merge** successful work or **forget** failed attempts
+5. **Clean up** directories after forgetting
+
+### Managing Multiple Workspaces
+
+List active workspaces regularly:
+
+```bash
+jj workspace list
+```
+
+Keep track of workspace purposes in notes or commit messages.
+
+### Resource Considerations
+
+Each workspace is a full working copy, consuming disk space. Clean up unused workspaces promptly.
+
+## Workspace Commands Reference
+
+```bash
+# Create workspace from current commit
+jj workspace add --name=<name> work/<dir>
+
+# Create workspace from specific revision
+jj workspace add --name=<name> -r <rev> work/<dir>
+
+# List all workspaces
+jj workspace list
+
+# Forget workspace (keeps commits, removes workspace reference)
+jj workspace forget <name>
+
+# View all workspace commits
+jj log -r 'working_copies()'
+
+# Reference a workspace's current commit
+<workspace-name>@
+```
+
+## Limitations
+
+- **Disk space:** Each workspace is a full working copy
+- **Manual cleanup:** Must remember to forget and remove old workspaces
+- **Coordination:** When working in multiple workspaces, ensure you're in the correct directory
+- **Build artifacts:** Each workspace has its own build outputs, which can consume significant space
+
+## Related Skills
+
+- `jj-clone-third-party` - For examining external repositories
+- `jj-graft-third-party` - For integrating third-party repository history