AI-assisted development produces a lot of exhaust. A reviewer flags something out of scope. A workaround goes in "for now". The agent finds a bug in a file it wasn't asked to touch. I correct its approach for the third time. In most projects, that exhaust evaporates. In ParkEase, it had five places to land, and a hook that wouldn't let a task end until it had. Five harvest bins 1. learnings.md: fixes that cost time. Covered in post 6: 246 entries, read before every task. 2. suggestedtask.md: things found and deliberately not done. Every time the agent noticed something worth fixing that would bloat the current change, it added a row: where it was found, why it was deferred, and what "done" means for it. By the end, 162 findings had been logged this way. The rule behind it: Keeping a task the size it was scoped to be is right; dropping the finding on the floor is not. That one rule ended "I noticed X but didn't mention it", which is where AI-assisted projects quietly rot. Rows get closed later, in batches, by whichever task naturally touches that code. 3. ponytail: comments: shortcuts with a label. When the agent deliberately cut a corner, the code says so, names the ceiling and the upgrade path (post 4). Debt you can grep for isn't hidden debt. 4. Decision records: structural choices. 34 of them. When a tool or a skill gave advice that contradicted a decision, the decision won and the agent had to say so. When a decision changed, it was amended in writing, never silently. 5. Memory: corrections to how the AI works. Claude Code keeps a small per-project memory. Every time I corrected the agent's behaviour, not just its code, that correction became a memory with the reason attached. A few that stuck: Research first. After it guessed four wrong prop names on a map library one at a time, instead of reading the type definitions once. Run gates, don't narrate them. After it wrote "Security: raw-body HMAC, amount re-fetched" into a checklist (a description of the code, not a review) and called the review done. Token budget over ceremony. After about 40 reviewer agents on one task ate most of a week's usage limit. Twelve of the project's memories are behavioural corrections like these. Each one is a mistake that happened exactly once. The hook that enforces it Good intentions don't survive a long session, so harvesting is enforced by a hook: a script that runs whenever the agent tries to finish. If the task was complex (three or more file edits) and none of the learnings, test-case or decision files were touched, the agent isn't allowed to stop. It checks the files' modification times, so intent doesn't count; only a written entry does. The same hook also watches the agent's final message for the classic rationalizations, phrases like "this is a pre-existing issue", "skipping tests for now", or "tests are failing but I'll fix them later". Saying one doesn't end the task; it blocks it. What harvesting bought The second half of the project was noticeably smoother than the first, and it wasn't because the model changed. The repo had learned. Traps that cost an hour in week one cost a four-second read in week four. Review findings didn't vanish. And the agent's worst habits, guessing, narrating, over-dispatching, each got corrected once and stayed corrected. The model forgets everything every session. The project doesn't have to. Next (bonus posts): the series continues with stories I didn't plan to tell, starting with being offered 292 skills and installing 21. ParkEase is a peer-to-peer parking marketplace for India, built solo with Claude Code. Code: https://github.com/Deonkar/parkease