Delegate the whole task, including the setup

Reduce friction in giving instructions

Input comfort changes what work gets started

Theo describes changing his workflow after a hand injury. Voice entry lets him give fuller instructions without relying on his usual keyboard habits. The benefit is more than entering the same words faster. A comfortable input method can make it practical to give context, start a task, and correct a misunderstanding when typing would otherwise discourage the request.

Technical vocabulary needs attention

Dictation can mishear library names and project terms. Custom vocabulary and enough surrounding context help. The transcript records Theo's experience with a particular tool, not a comparison of every dictation product.

Test the microphone in the actual workplace

Close placement can make quiet dictation practical

Theo demonstrates using a small podium microphone close to his mouth. He says this lets him speak quietly and reduces interference from nearby speech. The useful test is whether the recognizer understands quiet speech in the place where the tool will be used. Recording quality in a silent room does not establish that result. Nearby conversations and microphone distance can change the experience.

Evaluate the whole input setup

The lesson is about microphone placement, background noise, recognition, and social comfort together. An expensive recording microphone is not automatically the best dictation setup.

Let the agent handle command syntax

Voice and terminal commands are an awkward combination

Theo finds dictating paths, flags, and shell commands unpleasant. He prefers giving the goal in a visual app and having the agent run the commands. The delegation moves responsibility for exact syntax to the agent while keeping the desired result with the person. The agent still needs access to the machine, the relevant tools, and a way to verify that its command achieved the goal.

Document the machines an agent can use

His fleet repository records machines, connection details, installed tools, and intended uses. This lets an agent choose and operate the right computer without asking him to remember each setup.

Delegate file handling across machines

The file-transfer example includes waiting for a download, extracting a file, locating it, and transferring it. The useful unit of delegation is the completed transfer, not one shell command.

Isolate experiments from everyday tools

A major state change may need a separate install

Theo explains that the orchestration work changes persistence enough that a simple feature flag is not the isolation he wants. He asks for a separate build that will not interfere with his main installation. The important boundary is the state shared with the everyday installation. A separate experiment can fail or change its data model without disrupting the version used for normal work. A toggle is insufficient if both versions still modify the same state.

Start delegation before repository preparation

The request includes finding the work, checking out the right code, building it, and installing it. Manually doing those steps first would leave much of the task outside the agent's scope.

Delegate long computer-use chores

A multi-step browser task can be the whole request

Theo describes downloading records from a cumbersome portal, then handling a separate upload task. The example illustrates navigation across repeated screens and files. The request describes a result across multiple screens, not just a click sequence. The agent must navigate the portal, handle the relevant files, and verify the final state. Progress through the screens is not the same as completing the job.

Separate your availability from the job's duration

A dedicated computer can keep working while you leave or close a laptop. This makes it possible to start tasks that you would otherwise postpone because you cannot finish them in one sitting.

Expand both ends of the agent workflow

Include investigation and verification in the brief

Ask the agent to investigate the problem, implement the change, exercise the app, and gather review feedback. Otherwise the human still owns the tedious work on both sides of coding. This makes the completion boundary explicit. A code change that has not been exercised or reviewed still leaves work for the person who delegated it. The brief should say what evidence and follow-up are needed before the result is ready.

Treat autonomous merging as a reported practice

Theo describes allowing agents to merge some changes and gives his own regression count. That is an anecdote about his projects and checks, not a controlled comparison or a universal reliability rate.

Match speed to the working pattern

Background work does not always need the fastest model

When a task runs while you do something else, a shorter generation time may make little practical difference. Live iteration and urgent fixes are different. The value of lower latency depends on when a person needs the answer. For an unattended task, correctness and completion may matter more. For live design work, shorter feedback can let the person test more changes without losing context.

Dispatch work without watching every response

Theo shows starting a thread in the background and returning when it needs attention. Keeping work isolated makes this easier than serial edits in one long-running thread.

Correct misunderstandings rather than every typo

His dictation advice is to send a comprehensible request even if it contains minor errors. Correct it when meaning changes instead of spending effort polishing every input.

Ask for the context you need

Request a relevant digest instead of browsing every PR

Theo asks for short summaries of recent changes and why each matters to him. That turns repository activity into a review queue based on his concerns. A useful digest answers what changed, why it matters to the requester, and which decisions still need attention. It should help the person choose where to look next rather than replace the full record of every pull request.

Use prior threads as discoverable context

He asks a new agent to find and use an earlier conversation instead of manually copying it. This may cost more inference, but reduces a task that is physically awkward for him.

Compare your manual process with an early agent run

His suggested experiment is to send the outcome before doing the usual preparation. Then compare the agent's progress with what you did manually and see which steps were unnecessary.