# Notes from Armin Ronacher Using Claude Code

## Sources

YouTubes:

- Claude Vibe Codes a Sentry Clone
- Claude Code Fixes Two MiniJinja Issues
- Agentic Coding： The Future of Software Development with Agents

## Tips

- use `claude --dangerously-skip-permissions` for YOLO mode
- use the `playright` MCP so Claude can use a browser and make screenshots to see what's happening
- "before implementing this, please think through the problem and come up with a plan"
- for existing codebases, good and fast tools, and observability are critical (see section)
- use O3 to generate architecture first
- you can use other LLM tools via shell tools too e.g. the `gemini` CLI
  - use this for especially _tricky_ tasks
- (not from Ronacher) you can use `/init` at any time, it will _update_ `CLAUDE.md` if it exists
  - `#memorize` might not work as well (anecdotally)

### Conserve Context + Provide Tools + Observability

#### Conserve Context

- __don't__ use `/compact` (it's too non-deterministic)
- provide summaries of documentation for the agent (of libraries etc)
- provide a tool in each code base that can make/refresh a summary of all code
- provide a tool to Claude so he can run the above tool and glimpse the summary
- use shell tools rather than MCPs (except Playwright) - context is too short
- provide a tool to look at the last 20 lines of the logs, as well as additional lines when needed

##### Use subtasks/sub-agents

#### Provide Tools

- put them all in `Makefile`
- make it clear how to use a tool, so you don't get
  - silent failures ("all tests ran" even though it found zero)
- early on ask Claude to use a tool and see if it's working well
- for tricky concurrency bugs, give a tool it can put in the codebase to generate logs for debugging

#### Observability

- use a unified log (a single file with all logs)
  - SQL logs maybe (unless too verbose; otherwise put it in a separate log that's available to CC)
- forward console.log in the browser to a log file
  - https://github.com/mitsuhiko/vite-console-forward-plugin
- `make tail-logs`

## TODO

- [ ] Determine what he puts in his systemwide `CLAUDE.md`
  - https://github.com/mitsuhiko/agent-prompts
  - "here's how you write throwaway code: <where to place it> <how to run it>"
    ```markdown
        * When analyzing large codebases or multiple files that might exceed
         context limits, use the Gemini CLI with its massive context window.
        * Use gemini -p when:
        - Analyzing entire codebases or large directories
        - Comparing multiple large files
        - Need to understand project-wide patterns or architecture
        - Checking for the presence of certain coding patterns across the entire codebase

        Examples:

        gemini -p "@src/main.py Explain this file's purpose and structure"
        gemini -p "@src/ Summarize the architecture of this codebase"
        gemini -p "@src/ Are there any React hooks that handle WebSocket connections? List them with file paths"
    ```
- [ ] get set up with his "unified log"
  - https://github.com/mitsuhiko/vite-console-forward-plugin
- [ ] learn how to use `.claude/commands`
  - [ ] ronacher
  - [ ] disler
  - [ ] ...

### small

What are these? 
- [ ] `git sync`
- [ ] `git autotrack`

# Nuggets

- you can use CC to do web research via `playright`, for non-coding things too
- you can also use it to _do_ things on the web like selling stuff IRL
- `uvx` to not have to deal with installing dependencies
- use golang or PHP over Python
- don't commit to an annual subscription of _anything_ because these tools are evolving so much

> With AI, every nation, every corporation will want its own models, its own control, its own stake in the future.
— https://lucumr.pocoo.org/2025/6/4/changes/

- this is very interesting; it points to where the juice is going to be: custom models, or at least custom agents.