Reverse index

What is happening → what to do

Look things up by symptom, not by title. The link under "what to do" jumps to the section that describes the mechanism. The list of articles is at the bottom of the page, outside the reverse index.

This table assumes Claude Code (Anthropic's coding agent). hook, CLAUDE.md, subagent and auto memory are the names of its features.

The line a person types when something goes wrong

「Clear all todos. Check https://typing-tube.net/articles/en/lookup.md, look back over this session and see whether anything went wrong.」

This only gets you a list of problems. How to fix them is yours to decide, to fit your own project.

Open as markdown The recommended way is to rebuild it to fit your own project. A rebuilt table is free to use without attribution. Any row used as is, even one, is covered by CC BY 4.0, and attribution is a condition. That lets whoever takes over trace where it came from. To hand it to an AI, do not paste the table; pass the URL with the line above.

Sponsor

What is happening	Suggested approach
No.1 Every time the AI runs the tests, tens of thousands of output lines flood the context	Example:Route test runs through a wrapper and return only a failure summary to the AI. The Art of Not Reading #1: The Art of Not Reading Test Output
No.2 The more knowledge notes the AI saves, the more every future session has to read	Example:Have it read a checklist before writing to memory, and keep the always-read file to one line. The Art of Not Reading #2: The Art of Not Reading Memory
No.3 The tests pass, but it's unclear whether they actually protect anything	Example:Have the AI run mutation testing. The Art of Not Reading #3: The Art of Not Reading Unit Tests
No.4 The AI sometimes uses a registered skill and sometimes doesn't	Example:Block incorrect invocations at the entry point, and point to the doc it should read. The Art of Not Reading #4: The Art of Not Using Skills
No.5 Once work is handed to a sub-agent, you can't see what's happening until it finishes	Example:List the tasks that may be delegated, and check them with a hook before launch. The Art of Not Reading #5: Read Your Subagents' Output, and Only That
No.6 The more rules you add to the instruction file, the less the earlier rules get followed	Example:Rewrite each "don't" rule, one at a time, as a test that detects the violation. The Art of Not Reading #6: The Art of Not Reading Rules
No.7 Memory shared across parallel sessions gets messy, and having them read the policy doesn't help	Example:Keep the content unchanged; only change the timing to right after a save. The Art of Not Reading #7: The Art of Not Tidying Shared Memory
No.8 Even after writing down how to handle a failure, the AI makes the same mistake again next time	Example:Auto-insert the retry policy the moment a failure is detected. The Art of Not Reading #8: The Art of Not Reading Fix History
No.9 Even reading the handoff notes and completion report, the inconvenient parts are missing	Example:Place machine-counted numbers next to the completion report, every time. The Art of Not Reading #9: The Art of Not Reading Handoffs
No.10 Numbers the machine counted turn into different numbers by the time they reach the report	Example:Tag the number line with a fixed prefix, and use a hook to check it was copied verbatim. The Art of Not Reading #10: The Art of Not Asking AI to Summarize
No.11 Interrupting the AI mid-task throws off everything it does afterward	Example:Don't interrupt mid-task; wait for a break. Leave interrupting to the mechanism. The Art of Not Reading #11: The Art of Not Cutting In
No.12 At the end of a session, it's undecided what needs reading and what doesn't	Example:Don't read the deliverable or the work log; judge pass or fail only by the exit code. The Art of Not Reading #12: The Art of Not Reading Work Results
No.13 A proposal you already rejected comes back again in the next session	Example:Consolidate rejected decisions into a single document. The Art of Not Listening to the AI's Opinions #1: The Art of Not Weighing Up Proposals
No.14 Even with a one-line prohibition written down, it gets both over- and under-interpreted	Example:Write a "reason" next to each prohibition's conclusion. The Art of Not Listening to the AI's Opinions #2: The Art of Not Writing Prohibitions
No.15 The prohibition is written correctly but not followed, and each time someone asks about it	Example:Write a "scope" for each prohibition, listing the borderline cases one by one. The Art of Not Listening to the AI's Opinions #3: The Art of Not Creating Rules That Forbid
No.16 Give the same instructions to several sub-agents and each one comes back in a different shape	Example:In the list of tasks that may be delegated, state the inputs required before launch. The Art of Not Listening to the AI's Opinions #4: Check Your Subagents' Input, and Only That
No.17 Prohibitions with no automated test pile up, staying nothing more than text on a page	Example:For each prohibition, state whether a matching automated test exists. The Art of Not Listening to the AI's Opinions #5: The Art of Not Writing Automated Tests
No.18 Every piece of AI work ends with "please open the screen and check it"	Example:Judge pass or fail by the data left behind, not by how the screen looks. The Art of Not Listening to the AI's Opinions #6: The Art of Turning Down the AI's Requests to Check
No.19 Every time the AI says something slightly off, you're the one explaining and fixing it	Example:Instead of a person explaining it, return it via a hook and test failure messages. The Art of Not Listening to the AI's Opinions #7: The Art of Not Listening to What the AI Says
No.20 The list of rejected decisions keeps growing and looks headed for the point where nobody reads it	Example:Send rejected proposals to a "not adopted" section at the end. The Art of Not Listening to the AI's Opinions #8: The Art of Not Tidying Rules
No.21 The instruction file's "always run this" lines never seem to shrink	Example:Cross-check that commands the instruction file marks "always run" also exist as a mechanism. The Art of Not Telling #1: The Art of Not Asking for Verification
No.22 Even after writing out exactly how to do it, the fix doesn't come back that way	Example:Don't dictate the procedure; just decide the inputs needed before starting. The Art of Not Telling #2: The Art of Not Giving Specific Instructions
No.23 Reporting a bug means writing out the steps and symptoms yourself, every single time	Example:Have the person write only one line on the symptom, and collect the rest automatically. The Art of Not Telling #3: The Art of Not Writing Up Bug Details
No.24 Typing "give me a plan first" every time is its own recurring chore	Example:Put a single design document in place, and the AI will follow its format. The Art of Not Telling #4: The Art of Not Asking for a Plan
No.25 The lines you most want followed are written the most emphatically, yet you can't tell whether that helps	Example:Stop measuring the effect; count lines with emphasis and set a cap. The Art of Not Telling #5: The Art of Not Driving the Point Home
No.26 A sub-agent's deliverable comes back in a different shape than you expected	Example:Decide the deliverable's acceptance criteria before handing off the task. The Art of Not Telling #6: Spell Out Your Subagents' Output, and Only That
No.27 Finding a mistake makes you want to demand, "did you actually read this?"	Example:Don't interrogate; ask in the form "isn't it ...?" The Art of Not Telling #7: The Art of Not Interrogating the AI
No.28 Replying "that's not it" to the answer you got back doesn't make it any better	Example:Don't point it out yourself; show the prohibition with the diff right after the save. The Art of Not Telling #8: The Art of Not Criticizing the AI
No.29 The AI talks about a file's contents as though it had opened it, when it hasn't	Example:Have it write the same identifier in both the reference and the implementation, and use an automated test to check that identifier exists. The Art of Not Telling #9: The Art of Not Letting the AI Think
No.30 The AI keeps asking "A or B?" and work grinds to a halt while you decide	Example:Don't answer on the spot; let a mechanism decide the criterion instead. The Art of Not Telling #10: The Art of Not Answering Questions
No.31 The AI is doing the review, but it's unclear what it isn't looking at	Example:From the outside, find any automated test that scans files but has no lower-bound count check. The Art of Not Telling #11: The Art of Not Having the AI Review
No.32 Screenshots keep piling up, but it's unclear which one verified what	Example:Before shooting, have it state what's being verified, and try the cheapest method first. The Art of Not Checking #1: The Art of Not Taking Screenshots
No.33 A step that requires writing something down is in place, but you can't count how many runs skipped it	Example:Before a screenshot or E2E run, require a written statement of what's being verified, and refuse to run without one. The Art of Not Checking #2: The Art of Not Trusting the Declaration
No.34 The same test runs again even though the code hasn't changed, and you wait for it anyway	Example:Make the previous log replayable, so the same run doesn't need to be repeated. The Art of Not Checking #3: The Art of Not Re-running Tests
No.35 Nothing was broken, yet a wall of unfamiliar errors shows up	Example:Take an exclusive lock for the test run, and refuse to run without it. The Art of Not Checking #4: The Art of Not Reading False Failures
No.36 A report saying "the tests pass" doesn't mention the parts that never ran	Example:Skip heavy tests by default, and list the areas that didn't run, every time. The Art of Not Checking #5: The Art of Not Running Everything
No.37 There's no way to tell afterward whether an instruction specifying how to proceed was actually followed	Example:Don't strengthen the wording; make the procedure leave a trace in the deliverable. The Art of Not Running #1: The Art of Not Enforcing a Procedure
No.38 A wrapper you put in place gets abandoned partway through, back to the raw command	Example:Don't strengthen the wording; check whether a reason remains to fall back to the raw command. The Art of Not Running #2: The Art of Not Enforcing a Wrapper
No.39 Asking the same question repeatedly gets a different answer each time, and summarizing loses something	Example:Before merging, show how many out of how many raised each type of finding. The Art of Not Running #3: The Art of Not Aggregating
No.40 There's no way to tell whether a line that says "do X if needed" ever actually fired	Example:Don't write lines like "do X if needed"; block progress until the step is done. The Art of Not Running #4: The Art of Not Being Useful
No.41 Saying "think about it again" changes the answer, but it's unclear whether the AI is actually convinced	Example:Don't send it back; point out specifically which premise is wrong. The Art of Not Running #5: The Art of Not Making the AI Pick Again
No.42 Writing "don't guess" made the AI start coming back having built nothing at all	Example:Don't hand over only a prohibition; add an escape hatch like "not applicable." The Art of Not Running #6: The Art of Not Closing the Escape Hatch
No.43 The longer a conversation that's going well continues, the more effort it takes to verify	Example:End the session at a break, and start the next task in a new session. The Art of Not Running #7: The Art of Not Keeping a Session Going
No.44 Every deliverable is correct, yet waste that never shows up in them keeps building up	Example:Once the deliverables are complete, tally the work log once. The Art of Not Running #8: The Art of Not Judging by the Artifact
No.45 Notes left behind for the next person drift out of sync with reality and go stale	Example:Don't leave knowledge in a document; embed it in the stop message instead. The Art of Not Running #9: The Art of Not Leaving Notes Behind
No.46 Digging into the cause continues, and the reading keeps going even after the answer is found	Example:Count reads that changed nothing, and write a stopping condition before digging in. The Art of Not Chasing #1: The Art of Not Digging Deeper
No.47 The lowest-priced model is made the default without measuring whether it actually fits the use case	Example:Give the same task to both models, and decide only after counting turns and volume. The Art of Not Chasing #2: The Art of Not Using the Cheapest Model
No.48 When something isn't working, the fix reached for is a bigger model rather than a better mechanism	Example:Give the same task to both models, and turn the cheaper one's failures into an automated test. The Art of Not Chasing #3: The Art of Not Using the Latest Model
No.49 Research that the main session could finish on its own gets handed to a sub-agent just in case	Example:Don't delegate context the parent already has; hand off only what it's missing. The Art of Not Chasing #4: The Art of Not Using Subagents
No.50 The default move is to split the work into four and run them all at once, just because	Example:Give a sub-agent only what fits in one response. Cost is set by round trips, not count. The Art of Not Chasing #5: The Art of Not Using an Agent Team
No.53 "Take a look at this too" gets injected from outside partway through the work	Example:Wait for a break, then ask with a narrowed scope. Add: "say so if it's already sufficient." The Art of Not Chasing #6: The Art of Not Having It Reviewed Midway
No.52 Which model to use is being decided by comparing them head to head	Example:Before comparing, count how many mechanisms that comparison is worth in effort. The Art of Not Chasing #7: The Art of Not Choosing a Model
No.51 "There was no difference" is used as the reason to wrap up the verification	Example:Before wrapping up, recount results excluded from the tally and items that scored zero everywhere. The Art of Not Chasing #8: The Art of Not Letting It Give Up
No.54 One day the AI started working differently, and you changed neither your instructions nor your settings	Example:Don't write anything that conflicts with the product's instructions; add only what they leave undecided. Switch the setting to change how it works. 番外編 A-7 読まれたかを確かめる技術 —— 確かめるのをやめて、読めていない形を止めた

List of articles

From here down is not part of the reverse index: these are links to the articles, series by series, from the introduction to the final article.

はじめに —— 3 つの連載を、1 冊に

はじめに —— 3 つの連載を、1 冊に

はじめに —— 前巻の続きを、もう 1 冊に

はじめに —— 前巻の続きを、もう 1 冊に

What is happening → what to do

List of articles

はじめに —— 3 つの連載を、1 冊に

バイブコーディングにおける読まない技術

AIの意見を聞かない技術

言わない技術

付録

はじめに —— 前巻の続きを、もう 1 冊に

確かめない技術

動かさない技術

追わない技術

番外編