Geoff Code is a general-purpose terminal agent. You describe a goal in natural language; it reads the relevant code, plans, edits, runs commands, and verifies the result: pausing for your approval on anything that touches your files or shell. Below are the patterns it handles best.

​
Implement a new feature

Geoff Code follows a Read → Edit → Verify loop: it explores the relevant code, understands the structure, makes the change, then runs your tests or build to confirm it works.
Refine iteratively by pointing at a reference:

​
Fix a bug

Give Geoff Code a description, an error log, or a command that reproduces the problem. It locates the root cause, applies a fix, and re-runs the reproduction to confirm.

​
Understand a codebase

Drop into an unfamiliar repo and ask architectural questions. Geoff Code traces implementations, explains file purposes, and maps data flow without changing anything.
Run /init once on a new repo to generate an AGENTS.md summary that speeds up every later run.

​
Automate small coding tasks

Repetitive edits across many files are a sweet spot: exactly the kind of work that’s tedious by hand.

​
Automate general tasks

Geoff Code isn’t limited to code. Because it has shell access, it can handle research, log analysis, and batch file work.

​
Orchestrate other coding agents

Because Geoff Code has shell access, any coding agent with a headless mode is just another command it can run. That makes it a natural orchestrator: you describe the whole job to Geoff Code, and it decides what to do itself, what to hand to another agent, and how to check the results. A typical shape is Geoff Code as the planner and verifier, with other CLIs doing scoped chunks in parallel:
Most agent CLIs expose a one-shot, non-interactive entry point that fits this pattern: The delegated agent runs in the same working directory, so its edits land in your tree and Geoff Code can immediately read, test, or revert them. Geoff Code can also delegate to itself the same way, spawning geoff -p workers for independent sub-tasks when its built-in subagents aren’t the right fit.
Put the invocation conventions your team uses (which agent handles what, required flags, where output should go) in a skill so every session orchestrates the same way. Pair it with a hook that runs your formatter or test suite after each delegated agent finishes.
Approval prompts still apply. Every delegated agent is launched through Geoff Code’s shell tool, so you approve each one unless you’re running with -y. The delegated agent’s own permission model is separate: pass its equivalent auto-approve flag if you want it to run unattended.

​
Run it in scripts and CI

For unattended work, use non-interactive mode. Combine -p with -y (auto-approve) so the agent doesn’t block waiting for confirmation:
For machine-readable output in a pipeline, request streaming JSON:
-y (yolo) auto-approves every action including file writes and shell commands. Only use it in trusted, sandboxed, or disposable environments.

​
Keep going

Skills

Teach Geoff Code your team’s conventions and workflows.

Hooks

Auto-format, validate, and gate the agent’s actions.

Subagents

Delegate to specialized subagents with isolated context.