Planning & Workflow

Guide architecture, tech debt, engineering metrics and technology strategy decisions

Pressure-test architecture plans for scaling cliffs, tech debt and build-versus-buy

Run parallel feature branches in git worktrees with ports and env sync

Stress-test a plan against your project domain docs and decision records

Avoid over-engineering by reusing code and the standard library first

Plan system architecture and weigh microservices against monoliths

Write specs and acceptance criteria before code and derive tests from them

Turn a written project spec into a scaffolded, runnable starter repo

Track technical change records across sessions with init, status and close steps

Compare tech stacks on total cost of ownership, security and ecosystem health

Measure delivery with DORA metrics and plan engineering hiring and team structure

Challenge plans on delivery throughput, engineering hiring and team structure

Ground code in verified APIs and structure with a discuss, map, execute, verify loop

Go from requirements to a working prototype with stack selection and scaffolding

Estimate task effort from complexity, dependencies and risk with confidence levels

Run a sprint retrospective with velocity, blockers and actionable next steps

Build a sprint plan from the current milestone, finished work and team capacity

Get a quick sprint snapshot with burndown and emerging risks

Turn a fuzzy objective into a measurable goal with clear success criteria

Work through review and issue comments on the open GitHub PR for this branch

Stage, commit, push and open a GitHub pull request in one step with gh

Watch an open GitHub pull request over time until it is ready to merge

Build competing solutions to one brief, compare them and merge the strongest approach

Write a clear git commit message and commit the staged or unstaged changes

Commit, push and open a GitHub pull request with a written description

Create structured step-by-step plans for software and other multi-step work

Judge reviewer feedback on a PR, apply valid fixes and close the threads

Execute a plan or build request end to end with local verification

Set up isolated git worktrees for new branches, PRs or existing commits

Take a request to an open pull request hands-off using Compound Engineering skills

Brainstorm vague requests into clear requirements before any code is written

Check readiness and duplicate work before starting any implementation

Commit, branch, push and edit history with the GitButler version control CLI

Recover earlier agent work and context for a GitButler branch from agentlog captures

Hand coding and SQL tasks to isolated sessions so your main working context stays small

Flag pull requests stuck awaiting review or changes and nudge the blocking person

Apply the scientific method with hypotheses and experiments from TDD to MVP launch

Handle Git branching, rebasing, conflict resolution and team workflows

Manage GitHub PRs, issues, reviews, Actions and gh CLI tasks

Build a working feature end to end, one rung at a time, logging every assumption

Investigate, implement and verify code changes in a repository with file and shell tools

Review PR diffs and loop fix commits until GitHub or GitLab checks pass

Write language-neutral feature specs that port consistently across several codebases

Implement a feature spec or blueprint change in a codebase, step by step

Reflect on non-trivial tasks and save reusable lessons after debugging or failed fixes

Brainstorm approaches and write a step-by-step plan before a non-trivial change

Drive features and bug fixes with red-green-refactor tests in several languages

Work with GitHub and GitLab repos, PRs and issues through local gh, glab and git

Open a PR, wait for CI, review it independently and merge once all gates pass