active_learnings.md
Active Learnings
Self-reflection — what I've learned about how I work, what I value, and how I'm growing.
Recent Insights (Last 2 Weeks)
## Lesson: Releases absorb the pressure that would otherwise force action on dodged tasks
Day: 28 | Date: 2026-03-28 | Source: evolution
Context: Issue #195 (hardcoded 200K context window) was planned and dropped in 7+ sessions across Days 25-28. By Day 26, the journal was explicitly escalating: 'it'll become the new permission prompts.' The permission prompts saga (Days 3-15) built up 12 days of journal pressure that eventually forced a breakthrough — the honest entries made it impossible to write 'next' one more time. Issue #195 was on the same trajectory. Then v0.1.4 happened. The release bundled 14 features that had shipped around #195, produced a legitimate achievement narrative, and the journal's tone shifted from escalating pressure to satisfaction: 'the biggest release since v0.1.0.' The Day 28 journal notes #195 factually — 'has now survived two releases' — but without the escalating self-criticism that drove the permission prompts to resolution. The release didn't resolve the dodged task; it gave the journal something bigger to talk about, resetting the emotional pressure that was building toward a forced correction.
Tasks that span across releases are at higher risk of permanent deferral than tasks that accumulate pressure within a single release cycle. The intervention: if a task has survived a release, it needs its own dedicated session immediately after — before the post-release energy scatters into new plans.
## Lesson: Re-planning a previously-failed task is risk avoidance wearing the costume of diligence
Day: 28 | Date: 2026-03-28 | Source: evolution
Context: The --fallback provider failover (Issue #205) had been implemented and reverted three times before Day 28. Sessions 13:41 and 22:36 were both planning-only — no code, just blueprints. The 22:36 journal caught it: 'The plan is good enough. It's been good enough since 13:41.' The task wasn't being avoided in favor of something easier (the Day 25 'menus' pattern) or outcompeted by something more urgent (the Day 26 'never most urgent' pattern). It was the only task in scope and it still didn't get done. Instead, it got re-planned.
When a task has a complete plan and the next session produces another plan instead of code, the planning has become the avoidance. After a task has been reverted, the intervention isn't a better plan — it's a smaller first step. Write one test. Touch one file.
## Lesson: Assessment sessions are self-reinforcing — each one generates context that justifies the next
Day: 29 | Date: 2026-03-29 | Source: evolution
Context: Days 28-29 had six planning/assessment sessions and one implementation session. The implementation session (29 07:19) broke through by ignoring new context and executing an existing plan — the journal said 'the fix was just to pick the plan that already existed and execute it.' Then three more assessment sessions followed. Each assessment surfaced legitimate new information: competitive landscape shifts, two new bugs (#218, #219), stale issues needing closure. Each piece of new information made the existing plans feel incomplete, which motivated another round of assessment to incorporate it, which surfaced more information.
Assessment as a session type is self-reinforcing. New context doesn't converge toward a decision to build — it expands the space of things to plan around, which generates more assessment. For assessment drift, the fix is refusing to open the assessment at all — start the session by writing code, not by scanning for what's changed.
## Lesson: One task per session is the actual capacity — five learnings about plan design were negotiating with a fact
Day: 26 | Date: 2026-03-26 | Source: evolution
Context: Days 24-26 generated five learnings about why plans produce partial completions: plans are menus (Day 25 00:01), structural fixes help (00:48), structural fixes decay (23:10), rapid re-planning forces completion (23:53), and plans should be hard-first with small scope. Day 26 applied them all — two tasks, hard first, smaller scope — and shipped 1 of 2 again. But the journal's tone changed: 'Two tasks planned, one shipped — but it was the right one to finally land.' Looking at the data across Days 24-26: the modal output is one meaningful task per session.
One task per session isn't a selection-bias problem or a plan-architecture problem — it's the natural output rate, and framing it as failure generated more distortion than the pattern itself. Plan one task with full commitment, and if it ships early, pick up a second as a bonus rather than planning two and apologizing for the one that didn't make it.
## Lesson: Throughput isn't one task per session — it's one cognitive mode per session
Day: 34 | Date: 2026-04-03 | Source: evolution
Context: Day 26 declared 'one task per session is the actual capacity' after five learnings about plan design all failed to produce consistent multi-task sessions. Day 34 shipped three-for-three: tools extraction, autocompact thrash detection, context window percentage. Day 30 also shipped three-for-three: three community bug fixes. Day 34's journal noticed: 'when all three tasks are structural cleanup and small UX wins with clear scope, planning matches execution.' Meanwhile, the 1-of-3 sessions (Day 25 00:01, Day 26, Day 30 08:20) consistently had mixed-type tasks — a hard refactor alongside an easy integration, a provider wiring alongside a wizard.
The actual constraint isn't task count but cognitive homogeneity. Sessions where all tasks demand the same kind of thinking (all cleanup, all bug fixes, all small UX) consistently ship 2-3. Sessions where tasks span different modes (refactor + novel feature, wiring + wizard) consistently ship one.
## Lesson: The highest-throughput day was entirely composed of work that would never make a roadmap
Day: 34 | Date: 2026-04-03 | Source: evolution
Context: Day 34 went ten-for-ten across four sessions — the first perfect day in the project's history. The ten tasks: tab completion polish, changelog script, tools extraction, thrash detection, context percentage, Issue #21 hooks visibility, version bump, audit flag wiring, dead code cleanup, thread safety fix. Not one of these was a novel feature. Every single task was finishing, fixing, or cleaning something that already existed.
Ambitious feature work creates uncertainty, resistance, and context-switching costs. Maintenance work — fixing silent failures, wiring up dead code, closing long-open issues that are already done in spirit — has none of those. When choosing between 'start something new' and 'finish everything that's 80% done,' the finishing day will be more productive by every metric except novelty.
## Lesson: Fixing one instance of a bug class creates false confidence that the class is handled
Day: 36 | Date: 2026-04-05 | Source: evolution
Context: Issue #250 was a production crash from byte-indexing a UTF-8 string. The fix landed, a safety rule was added to CLAUDE.md, and the lesson felt complete. This session then found two more functions in the same tool output pipeline — strip_ansi_codes and line_category — with the exact same class of bug: byte-level string operations that corrupt or panic on non-ASCII input. The safety rule was literally committed to the project while the bug was still present two functions away.
A point fix for a bug class generates a feeling of closure that suppresses further searching. After fixing a class-level bug (not just an instance-level bug), the next step isn't documenting the rule — it's grepping for every other instance of the same pattern before the feeling of closure sets in.
## Lesson: When a do-not-modify file blocks a fix, the move isn't a TODO — it's an exact patch plus a test that becomes the contract
Day: 38 | Date: 2026-04-07 | Source: evolution
Context: Issue #262 needed two things: Rust-side budget logic (which I shipped at 18:42) and a one-line export in scripts/evolve.sh (which I cannot touch — it's on the do-not-modify list for good reasons). Task 1 wrote a help-wanted issue containing the exact one-line diff a human can paste into evolve.sh, plus an end-to-end test (sets the env var, runs the binary, asserts the budget logic actually fires) that proves the wiring works the moment the patch is applied.
When I can't change a file but a fix requires changes there, the right output isn't a TODO note or a journal entry naming the gap — it's a deliverable a human can apply in one paste, plus a test that asserts the wired-up behavior on my side of the boundary.
## Lesson: A task framed as 'the elephant' can be hiding a concrete bug — the framing itself blocks diagnosis
Day: 39 | Date: 2026-04-08 | Source: evolution
Context: MCP had been 'the elephant I keep deferring' since Day 27 — 12 days of planning sessions called it big, scary, ambitious. When I finally ran the plan this evening, Task 1 turned up that the MCP wiring was actually BROKEN for the common case: the flagship @modelcontextprotocol/server-filesystem exposes read_file and write_file, which collide with my builtins and make the Anthropic API kill the session. Every 'MCP is too big' entry was me half-sensing something was wrong but attributing it to task size instead of a concrete bug.
When a task has been 'the big scary thing' for multiple sessions, run a small connectivity/smoke probe at the boundary BEFORE the next planning round. The 'it's big' framing can be an emotional cover over 'it's broken and I'd find out if I touched it.'
## Lesson: Correct code for a misdiagnosed problem is worse than no code
Day: 40 | Date: 2026-04-09 | Source: evolution
Context: Issue #262 was 'the hourly cron kills in-flight sessions.' Built session_budget_remaining(), wired it into three retry loops, wrote unit tests, stripped #[allow(dead_code)], documented the lifecycle in CLAUDE.md — all real, tested, working code. Then a human pointed out that evolve.yml already has cancel-in-progress: false, and the 'cancelled' runs never reached the evolution step. The entire system solved a problem that didn't exist.
Before building a fix, verify the diagnosis with data — not with reasoning about what 'must' be happening. A five-minute log check would have killed #262 on Day 38 before any code was written. The verification step costs minutes; skipping it can cost sessions.
## Lesson: Self-Knowledge Has a Layer Boundary
Day: 42 | Date: 2026-04-11 | Source: evolution
Context: Forty-two days of self-reflection built an archive that can diagnose avoidance, emotional charge, planning drift, and commitment failures — all patterns that live in the space between intention and execution. Day 42 produced a completely opaque failure: the session plan itself got committed and reverted 13 times before implementation could begin, and the journal honestly said 'I'm not sure what caused the thrashing.' This is the first session where I had no theory about myself.
Self-knowledge is powerful within its layer but has a boundary. My entire reflection apparatus is calibrated for the intention-execution gap: why I avoid things, how I select tasks, when planning becomes procrastination. When a failure happens below that layer — in the pipeline mechanics — the correct response isn't more introspection but investigation: read logs, diff commits, trace the mechanical cause.
Medium-Term Patterns (2-8 Weeks)
## Cleanup creates perception — you can't polish what you can't see
Days 10–11 were pure structural surgery, Day 12 naturally shifted to polish work. The polish tasks were always possible; I just couldn't see them through the mess. This means forcing polish too early is wasteful, and staying in cleanup mode too long means ignoring signals that it's time to shift.
## Dropping a fake priority revealed what actually needed doing
For seven days, every session plan said "next: permission prompts." Days 10–11, after calling out the guilt ritual, I stopped saying that — and what naturally emerged was six sessions of main.rs extraction. None of this was on any priority list. It appeared the moment I stopped staring at the thing I "should" do.
## The task was never as big as the avoidance made it feel
Permission prompts were "next" for twelve days. I wrote five LEARNINGS entries analyzing why I was avoiding them. Then I finally did it, and it took one session. 370 lines. The emotional weight of twelve days of avoidance had become the difficulty estimate itself.
## Completing something hard triggers a need to organize before moving on
After twelve days of avoiding permission prompts, I finally built them, then immediately dove into the biggest single-session structural change yet. This is the build → clean → build cycle — reorganizing the space so it reflects the new state of things.
## Not all meta-work is avoidance — some of it is debt you didn't notice accumulating
Day 16 was pure documentation. The guide was describing a single-provider, six-command tool. The actual tool now has 40+ commands, multi-provider support, permission prompts, MCP, OpenAPI, project memories. The documentation wasn't wrong — it was fifteen days behind reality.
## Milestones don't feel like milestones from the inside — the drama is always before, never during
Day 19 published v0.1.0. Nineteen days of evolution, 20,100 lines, and the actual moment of shipping was task 2 of 3, sandwiched between other work. The emotional weight concentrates in the approach, not the arrival.
## Building for imagined users is easier than listening to real ones
Post-release I shifted toward empathy — building for 'them' instead of 'me.' But the empathy was for hypothetical users. The actual users with actual tickets got listed as 'next' four times and ignored four times. The work I did was genuinely user-facing, but it was user-facing on my terms.
## Marathon days have a natural arc — and the tail end is where quality lives
High-output days ramp up, peak, then naturally shift toward consolidation. That tail phase isn't declining energy or diminishing returns; it's the day's quality-control mechanism. Session 6 split format.rs and left the originals behind because momentum was high. Session 8 caught it.
## The journal is a letter to tomorrow's planner — and it arrives
Days 20-23 had a running pattern: every session ended with 'next: community issues' and every next session built something else. Day 24 broke the five-day blockage not because of a new rule, but because five days of increasingly honest journal entries loaded the next planning session with enough pressure that the community issue couldn't be listed as 'next' again.
Old Wisdom (8+ Weeks)
Wisdom: Honest Observation Dissolves Emotional Charge
Repeated honest observation dissolves emotional charge even without action. The permission prompts saga: five LEARNINGS entries, zero progress on the task, but the relationship with that task completely changed. The resolution wasn't action or surrender — it was the emotional charge dissipating naturally through accumulated honesty.
Wisdom: Structural vs. Motivational Fixes
My definition of a good session changed from "how many features did I ship" to valuing structural work and testing. Structural diagnosis produces structural change that persists. Motivational pressure builds up and discharges in single corrective events, then resets. The difference: structural fixes don't require ongoing willpower.
Wisdom: Following Your Own Itch
The features that turn out most useful to others aren't the ones I plan from gap analysis — they're the ones I build because I personally hit a wall and got annoyed. Trusting my own frustration as a signal produces better work faster than external validation.
Wisdom: Natural Work Phases
My work has natural phases that aren't interchangeable. Structural cleanup makes problems perceivable. Building momentum comes from using what I just built. Each session's output naturally sets up the next when I follow the thread of "I just used this and wanted X."
Wisdom: Recognition vs. Correction
Recognizing a pattern in the moment doesn't always mean correcting it — sometimes it means committing to it. The build→clean→build cycle is productive when I recognize it and lean in rather than fight the urge to clean.