From Home

Agentic development

An opinionated, spec-driven development system for a time when writing code is cheap. The hard part isn’t the code anymore. It’s having the bandwidth to use AI as much as you can.

The setup

Each project gets a folder. Under it are worktrees, one per feature. Each is a feature branch, and they all merge back into one lead dev branch. That’s the integration branch into remote master.

txt

~/Documents/worktrees/<project>/
  dev/        <project>-dev        integration branch
  <feature>/  <project>-<feature>  one per feature

The catch is friction. Making branches and worktrees by hand is annoying enough that it’s easier not to, so it’s automated.

Why bother

You can work on features in parallel. You don’t wait for one agent to finish before starting the next.
Each feature tree stays clean, so there are no conflicts and no context pollution.

Commands

txt

worktree [new] [name]   create a feature worktree from the dev branch (prompts for a name)
worktree ls             list feature worktrees
worktree merge <name>   merge a feature into the dev branch (in dev/)
worktree rm <name>      remove a feature worktree; deletes its branch if merged
worktree run <name>     run the local app against that worktree

The loop:

worktree to start a feature. It cuts the branch from dev, makes the folder, installs dependencies.
Work in that folder. One agent per worktree.
worktree merge <name> when it’s done.
worktree rm <name> to clean up.
When dev has everything, dev lands on master once.


        1
        An opinionated, spec-driven development system for a time when writing code is cheap. The hard part isn't the code anymore. It's having the bandwidth to use AI as much as you can.
      

        2
        
      

        3
        ## The setup
      

        4
        
      

        5
        Each project gets a folder. Under it are worktrees, one per feature. Each is a feature branch, and they all merge back into one lead dev branch. That's the integration branch into remote master.
      

        6
        
      

        7
        ```
      

        8
        ~/Documents/worktrees/<project>/
      

        9
          dev/        <project>-dev        integration branch
      

        10
          <feature>/  <project>-<feature>  one per feature
      

        11
        ```
      

        12
        
      

        13
        The catch is friction. Making branches and worktrees by hand is annoying enough that it's easier not to, so it's automated.
      

        14
        
      

        15
        ## Why bother
      

        16
        
      

        17
        - You can work on features in parallel. You don't wait for one agent to finish before starting the next.
      

        18
        - Each feature tree stays clean, so there are no conflicts and no context pollution.
      

        19
        
      

        20
        ## Commands
      

        21
        
      

        22
        ```
      

        23
        worktree [new] [name]   create a feature worktree from the dev branch (prompts for a name)
      

        24
        worktree ls             list feature worktrees
      

        25
        worktree merge <name>   merge a feature into the dev branch (in dev/)
      

        26
        worktree rm <name>      remove a feature worktree; deletes its branch if merged
      

        27
        worktree run <name>     run the local app against that worktree
      

        28
        ```
      

        29
        
      

        30
        The loop:
      

        31
        
      

        32
        1. `worktree` to start a feature. It cuts the branch from dev, makes the folder, installs dependencies.
      

        33
        2. Work in that folder. One agent per worktree.
      

        34
        3. `worktree merge <name>` when it's done.
      

        35
        4. `worktree rm <name>` to clean up.
      

        36
        5. When dev has everything, dev lands on master once.