Getting more out of Codex or Claude Code starts with the work around them.
Much of the effort happens around the agent: gathering context, handing out small tasks, explaining the next step, and checking progress. Those handoffs take attention, even when the agent is doing useful work.
At The Agile Monkeys, we have been reorganizing our work around three habits that help us delegate more complete work and spend less energy coordinating it:
Be ambitious. Be a whisperer. Be lazy.
Here is how to put them to work, with a practice to take away from each section.
Be ambitious: give it a complete goal
Think back to a few recent requests. Could the agent have handled the work between them too?
We increasingly delegate a complete outcome: where to investigate, what to deliver, how to check it, and when to involve us. That gives the agent room to explore, plan, implement, and verify.
For a feature, an illustrative brief might be:
Make notification preferences work end to end. Inspect the code and propose a plan. After our approval, implement it, run the relevant checks, and test the flow in the development environment using the browser. Bring us a reviewable PR with the results. Ask us about missing product decisions; leave merging and production deployment for review.
We have used this approach for changes spanning several services. Once we approve the plan, the agent can keep going through implementation and testing. We return when there is something worth reviewing or a decision it needs us to make.
Even substantial requests can go further: include the initial investigation, or the verification that usually happens afterward.
Give it the outcome, the definition of done, and clear review points.
Be a whisperer: think out loud to the agent
Askomity push.
That is what the transcription produced when one of us said, in Spanish, haz commit y push: roughly, “do a commit and push.” The agent understood the intention and responded about committing and pushing the changes.
When preparing a presentation, we used voice to work through the structure, reshape slides, and rehearse the delivery. The agent turned that rambling into presenter notes and reminders of what to demonstrate.
We still write or edit exact wording when needed. For exploration, the conversation can start before the idea is fully organized.
Try a minute of thinking out loud, then ask the agent to clarify the goal and any open questions.
Start talking while thinking. Let the agent help find the structure.
Be lazy: let it find the context
A request arrives in Slack. Before work starts, there is a related issue to find, a document to read, and last week’s discussion to recover.
That preparation costs attention. Copying and pasting is work.
Connect the sources the work needs, with access appropriate to the task. We can then point to a conversation and let the agent investigate related information, including what we might have forgotten.
Distinguish what the agent can access from what it needs for this task. Keep the working context focused with concise tool results, especially under tighter model or token budgets.
Point to the sources. Let the agent do the gathering and connecting.
Turn those habits into a daily loop
Here is one way we put them together:
Email review. A scheduled task brings us the important messages at the start of the day. Initially, we checked the inbox too and corrected what it missed or included unnecessarily. Those corrections refined the criteria; we now rely much less on manual scanning.
These reviews now do more than filter relevant mail: they sometimes catch important messages we would have missed. One example was a certificate-expiry notice that could have left several of our internal services unavailable.
Priorities. A separate ongoing workflow reviews the connected sources and updates our priorities document in Notion. It can connect a chat request with a meeting tomorrow and surface what needs preparation today.
Parallel work. From those priorities, we launch independent goals: investigate this, prepare that proposal, start this implementation. We review the results, and completed work feeds back into the priorities.
Parallel work also means more conversations in an agent workspace (Codex, Claude Code, or another tool). Keeping active work visible takes some organization. One arrangement we use is:
- Permanent: recurring routines and scheduled tasks, such as the daily email review.
- Pinned: the work we are actively following.
- Key projects: projects we return to frequently.
Organization is personal; project folders may be enough. The useful test is whether work needing attention is easy to see and find.
Keep the priorities, delegated work, and completed results connected.
Make each correction useful next time
Useful knowledge can disappear into old chats. A knowledge workspace with an index, current work, project folders, and reusable instructions gives later sessions something to pick up.
Make upkeep part of the workflow, rather than another thing to remember. A skill or instructions in an agent’s file, such as AGENTS.md or CLAUDE.md, can make recording decisions, corrections, and remaining work part of the task.
Some of us use a scheduled task to review sessions that are largely finished, extract the useful lessons, and update our personal or project knowledge base. PR review feedback can feed the same workspace.
A manual session review is still useful at the end of a task:
What did we have to explain repeatedly? Propose updates to the reusable instructions, and save the decisions and remaining work so we can resume later.
Keep task-specific details in the relevant project notes, and review changes to reusable rules so a one-off correction does not become a blanket instruction. The lesson lives in files and examples that later runs actually read.
Save the lesson where future runs can read it—and make saving it routine.
Make the result easier to understand
Getting an agent to finish is only part of the job. A finished result is only useful if it is easy to understand and review.
Ask for a format that makes the next decision easier. A diagram can clarify service relationships. An HTML report can make a proposal easier to navigate. An interactive artifact can turn an explanation into something to explore.
We can save the explanation styles that work well as reusable instructions, including the diagrams and examples that make a result easier to follow.
Then question the result:
Why this approach? Which assumption does it depend on? Show us how you checked that it works.
For the billing example, an illustrative answer could look like this:
Now there is something specific to challenge: does that assumption hold, and do the checks support the decision?
Delegate some of the work of making the result reviewable.
Protect attention as parallel work grows
More agents can advance independently. Our capacity to switch between them still has a limit.
Prepare each goal so it can advance until there is a reviewable result, a blocker, or a decision that needs human input. Workstreams touching the same services may need coordination rather than simultaneous execution.
As coordination grows, a director agent with clear roles, session names, and documented state is one pattern to explore.
The environment matters too. Scripts that return check results and relevant errors can keep huge build logs out of the conversation. Different models may suit planning and execution, depending on the budget.
Keep asking: is this reducing the attention each task needs, or giving us more things to monitor?
Pick one practice and try it this week
Pick one new practice: think out loud, delegate a complete goal, connect a source, automate a daily review, or ask for a visual explanation.
Use it on a real task. Notice how often it needs intervention, what has to be repeated, and how much effort review takes. Adjust and try again; if it does not fit, choose another practice.
These habits reinforce one another. Connected context makes a spoken brief easier to act on. Clear goals let work advance further. Saved feedback reduces repeated corrections. Readable results make it easier to pick work up again.
One practice. One real task. Give it a proper try.
Keep building on what works. There is a title to work toward:
SWAT: Supreme Whisperer of All Time.