In today’s newsletter:

• Ten Rules That Reshape Claude Code Output

• Turn Old Agent Logs Into Training Environments

Reading time: 5 minutes.

Ten Rules That Reshape Claude Code Output

Claude Code often puts the action you need in the middle of a long response. Before showing the command or file change, it may explain the problem, add caveats, and suggest unrelated improvements.

Even when the answer is correct, you still have to scan the response to work out what to do first.

An open-source skill called i-have-adhd changes how Claude Code presents its work. The skill doesn’t add tools or modify the model. It gives Claude Code ten output rules designed to reduce the effort between reading an answer and acting on it.

Install the plugin and activate the skill inside Claude Code:

claude plugin marketplace add ayghri/i-have-adhd
claude plugin install i-have-adhd@i-have-adhd

Then enter /i-have-adhd. The rules remain active for the session until you enter stop adhd mode.

Here are the ten rules and what each one changes.

1. Lead With the Next Action

Claude Code often begins by explaining how it interpreted the problem. That context may be correct, but it delays the action you opened the terminal to perform.

The skill moves the command, file path, or code change to the first line.

Instead of:

You get:

The explanation can follow when it helps. The first line still tells you where to start.

2. Number Every Multi-Step Task

A paragraph can hide how much work an answer contains. “Open the file, update the function, run the tests, and inspect the result” looks like one instruction even though it contains four separate actions.

The skill converts multi-step work into a numbered sequence:

1. Open src/auth.ts.

2. Replace verifyToken.

3. Run npm test -- auth.spec.ts.

4. Inspect the first failure.

Each step contains one bounded action. You can see your current position without rereading the paragraph.

3. End With One Concrete Next Step

Coding-agent responses often finish with “Let me know if you want me to continue.” That leaves you responsible for deciding what should happen next.

The skill replaces the open-ended handoff with one action that takes less than two minutes:

A concrete handoff keeps the task moving. You don’t have to reconstruct the workflow after reading the response.

4. Suppress Tangents

Claude Code notices issues outside the task you gave it. While fixing authentication, it may also mention an outdated dependency, weak test coverage, and documentation that needs revision.

Those observations can be useful, but mixing them into the current fix increases the number of decisions you have to make at once.

The skill finishes the active task before raising a second issue. Any unrelated problem appears separately and only after the current work has a clear stopping point.

5. Restate the Current State

Long Claude Code sessions span several messages. A reply such as “Done. Ready for the next part?” assumes you remember which part just finished and what remains.

The skill carries the state into every turn:

The repeated state may look redundant in a transcript. During an active debugging session, it saves you from scrolling upward to recover the plan.

6. Give Time Estimates in Concrete Units

“This will take a while” doesn’t help you decide whether to continue now or return later.

The skill requires estimates in minutes, hours, or another specific unit:

Claude Code still cannot predict execution time perfectly. A concrete estimate gives you a usable range and names the condition that could change it.

7. Make Completed Work Visible

Agents often report progress through vague summaries such as “I updated the authentication flow.” You still have to inspect the diff or replay the session to learn what works now.

The skill names the completed outcome and tells you how to verify it:

Visible progress matters during long tasks because completed work becomes a checkpoint. If the next change fails, you know which earlier behavior should still pass.

8. Report Errors Without Drama

Error messages don’t need emotional framing. Phrases such as “Uh oh” or “There seems to be a problem” add words without helping you repair the failure.

The skill reports three pieces of information instead:

• Location: auth.spec.ts:42

• Cause: The request has no authentication header

• Fix: Add Authorization: Bearer ${token}

The error becomes another work item rather than a conversational event.

9. Keep Visible Lists Short

Claude Code can produce a long list whenever a task touches many files, warnings, or possible improvements. A complete list may contain useful information while still being difficult to act on.

The skill shows no more than five items in one group and ranks the most relevant items first. It doesn’t discard the remaining information. Claude Code keeps the rest available and surfaces it when those items become relevant.

That gives you a smaller working set without forcing the agent to ignore important findings.

10. Remove Preambles Recaps and Pleasantries

The final rule removes sentences that announce the answer, repeat completed work, or add a generic closing.

Claude Code stops opening with phrases such as “Great question” and “Let’s think through this.” It also stops ending with “Hope this helps” or “Feel free to ask if you need anything else.”

Once the filler is gone, each response follows the same useful sequence: action, necessary context, current state, and one next step. You spend less time extracting instructions from the conversation and more time completing the task.

i-have-adhd Skill on GitHub →

Turn Old Agent Logs Into Training Environments

Every coding agent leaves a detailed history behind. The history contains the files it read, the commands it ran, the edits it made, and the errors it encountered.

Most training pipelines treat that history as a demonstration to copy. Terminal-Universe recovers the workspace behind the history instead. The researchers used this method to build 37,273 executable environments from public coding-agent runs.

Those environments produced 31,977 verified training examples. Fine-tuning Qwen3.5-27B on them improved its Terminal-Bench 2.1 score by 11.9 points.

A Saved Run Only Teaches One Solution

A trajectory records one attempt at one task. If the agent took a poor route, made unnecessary edits, or recovered from avoidable mistakes, supervised fine-tuning teaches the model to imitate that behavior.

The training data is also fixed. You cannot give the same trajectory a different requirement, ask a stronger model to solve it, or run new tests against the final result.

An executable environment gives you those options. You can reset the workspace, create another task from the same code, let a different agent attempt it, and verify the result with tests.

The problem is that most public trajectories don’t include the original workspace. They only preserve the parts the agent happened to touch.

Terminal-Universe rebuilds the missing workspace from those records.

Rewind Every File the Agent Touched

The reconstruction starts with the agent’s file operations.

When the trajectory contains a file read, Terminal-Universe recovers the earliest version the agent saw. When the agent edits an existing file, the system restores the version from before that edit. Files created during the solution are removed so the recovered task starts unfinished.

The result is a partial copy of the original workspace. It includes the code exposed by the trajectory but may still be missing configuration files, dependencies, or source files the agent never opened.

A completion agent fills those gaps. The completion agent receives the partial workspace and the recovered task, then adds the context required to make the task solvable without adding the solution itself.

That second step made a large difference. Replay alone produced sufficient terminal environments 40.2% of the time. Adding agentic completion raised the rate to 93.5%.

Terminal-Universe then keeps only the environments that contain enough code, configuration, and dependencies to support the recovered task.

One Workspace Can Produce Several Tasks

Once a workspace runs again, the original request is no longer the only training example available.

Terminal-Universe uses each recovered workspace in four ways:

• Intent recovery. Recreate the original request and ask a stronger model to solve it again.

• Single-workspace tasks. Inspect the codebase and generate a different task that can be completed inside it.

• Cross-workspace tasks. Pair related codebases and ask the agent to move or adapt a capability from one project to another.

• Multi-round tasks. Continue the work across several requests while requirements change and previous changes remain in place.

Each generated task receives an executable verifier. A solution enters the training set only after the verifier’s tests pass.

The multi-round sessions keep useful failures too. Among the 3,079 retained sessions, 69.6% contained a failed round that the agent later repaired. The model therefore sees more than clean final answers. It sees how a coding task goes wrong and how later work corrects it.

Re-Solving Beats Imitating

The team built two training sets from the same 35,800 tasks. One kept the original agent trajectories. The other restored each environment and let a stronger teacher solve the task again.

Imitating the original trajectories reduced the model’s average score from 47.0 to 36.7. Training on the re-solved tasks raised it to 52.1 because the model learned stronger solutions instead of copying weak decisions and unnecessary steps.

The full training mixture pushed Qwen3.5-27B from 46.2% to 58.1% on Terminal-Bench 2.1. Adding new environments also helped more than generating extra solutions inside existing ones, since each workspace introduced different tools, dependencies, and failure modes.

Terminal-Universe turns agent histories into reusable practice environments. Successful runs become new tasks, while failed runs become repair exercises.

Read the Terminal-Universe Paper → 

That’s all for today. Thank you for reading today’s edition. See you in the next issue with more AI Engineering insights.

PS: We curate this AI Engineering content for free, and your support means everything. If you find value in what you read, consider sharing it with a friend or two.

Your feedback is valuable: If there’s a topic you’re stuck on or curious about, reply to this email. We’re building this for you, and your feedback helps shape what we send.

WORK WITH US

Looking to promote your company, product, or service to 200K+ AI developers? Get in touch today by replying to this email.