Here are some personal notes I gathered while working with AI tools and agents over the last month.
General Findings and Musings
- Most of the times I think we are too obsessed with the models. I found most of them to be good enough for my use cases, while my workflows are still all taped together. I am using Sonnet 4.5 as my daily driver. I think the devil is in the workflow and context. However, everyone raving about how good Opus 4.5 is makes it worth trying.
- Agents are very slow. This is a hell for folks with attention deficit. The fact that we argue for the benefits of worktrees with multiple pieces on the go is telling. We discard humans’ cognitive load and context window just because agents have context and speed problem is ironic.
- When it comes to extraneous tasks, automation, or migrations, it makes sense to have multiple agents working in parallel on irrelevant pieces of work. Yet to experiment with applying parallel agents for high-value product work that requires critical thinking and focus.
- I see lots of people are too focused on the agents, instead of actually building something with them. I think the learning is in the latter.
Commit Messages / PRs
Git commit messages provide a lot of context for future implementations. They essentially can be journaled to build context for the agents; therefore, I think there are more reasons to:
- Use proper commit messages and review them before committing.
- Do not squash the commits. Rebasing and fixing the commits is now more important than before.
- Avoid slops in PRs. Probably one of those areas where you want to review the AI-generated content thoroughly and amend.
Claude Code
Subagents
Running subagents in the background:
- Subagents can be run in the background. You can ask, “Start an explore agent in the background and find where client errors are handeled". That is equivalent to this command:
Task(
subagent_type=Explore,
prompt="Find where client errors are handled",
run_in_backgroun=true
)
- You can resume a paused agent by using the resume set to the original agent_id. When resumed, the agent continues with full context from the previous session—it remembers all the files it read, searches it performed, and conclusions it reached. This is powerful for iterative exploration. Here is the example of resuming the previous agent:
Task(
subagent_type=”Explore”,
prompt="Now check how errors are logged",
resume=ab28db
)
- While the above is really good for a non-blocking task, you and it cannot interact directly with each other. It means that if it requires a specific approval or a use
AskUserQuestiontool call to clarify something, it is likely to just die while waiting in the background. - Running agents in the background is ideal for self-contained tasks, such as exploration tasks.
- Claude uses the
Taskbuilt-in tool to start a subagent. If you want to know what they are up to, you can use theTaskOutput:
Run code-research in the background and call TaskOutput non-blocking to update me on its progress frequently.
That should be equivalent to:
TaskOutput(task_id="aba92f0", block=false, timeout=300000)
Built-in Tools
Claude comes with some built-in tools:
- Read - Read file contents (with line range support, handles images/PDFs/notebooks)
- Write - Create or overwrite files
- Edit - Make precise string replacements in files
- Glob - Fast file pattern matching (e.g., **/*.go)
- Grep - Code search with regex (powered by ripgrep)
- Task / TaskOutput
- Bash / Skill
- Etc.
We can use these in our prompts (such as custom agent instructions). Example:
(Rest of instructions markdown removed for brevity)
# Example: If current feature involves database changes
```
Grep(
pattern="## (Components|Database Changes|Data Structures|API Changes)",
path="docs/features/b001-fix-chunks/design.md",
output_mode="content",
-A=20 # Include 20 lines after match to get section content
)
```
# Example: If current feature involves API design
```
Grep(
pattern="## (Components|API|Data Flow|Error Handling)",
path="docs/features/f001-python-support/design.md",
output_mode="content",
-A=20
)
```
(Rest of instructions markdown removed for brevity)
Context7
There is an MCP with only two methods using Context7 (https://context7.com/). I use context7 mcp in the explore phase to download context for a specific library or framework. It’s pretty powerful.
(Rest of instructions markdown removed for brevity)
#### Step 3. **Use Context7** for library documentation when needed:
```
mcp__context7__resolve-library-id("library name")
→ mcp__context7__get-library-docs(context7CompatibleLibraryID, topic, mode="code")
```
(Rest of instructions markdown removed for brevity)
LLM Steering
I learned about LLM Steering. This is a very informative and easy-to-understand video on how to steer an LLM’s behaviour without Prompt Engineering or Fine-Tuning. Essentially, this is done between each attention block, where it is called Activation Space. The instructor demonstrates how to do this in an intuitive way towards the end, using the HF Transformer library.