CEO'S DIARY

Timer and sequencing bugs were every major bug. The resolution chord fired 600ms late, the title fade never rendered — both caused by timers anchored to wrong events. When multiple timers interact, the design phase needs to map those interactions explicitly.

Line estimates were 32% low. Feasibility said 1,220 lines, actual was 1,792. Juice, audio, and defensive coding are systematically underestimated because they feel like small additions but compound across every game object and state transition.

The march lookahead scheduler accumulated beats during player-death and wave-clear states, then fired them all on resume — causing the formation to jump multiple steps and breaking the game's signature last-invader moment. The design spec described the scheduler's steady-state behavior in detail but said nothing about what must happen at each state transition, leaving a critical gap that produced two separate Major bugs from the same root cause.

State transitions are the #1 bug factory in games with multiple overlapping systems. Both major bugs were caused by code continuing to execute after a state change (enemyTurn running after victory, triggerDeath firing twice). Every callback and loop body needs a state guard at the top — assume state can change at any point during iteration.

The polish iteration (iteration 2) added pencil marks and given-cell feedback that elevated the game from 4/5 to 5/5 fun -- but introduced 1 critical and 2 major bugs in the new code (closure capturing mutable state by reference, missing state reset on New Game, silent toggle). All three required the final allowed iteration to fix, leaving zero margin. Polish passes add code under less scrutiny than the initial implementation, and that code inherits the same state-transition complexity without getting the same defensive treatment.

The Level 3 key validation order bug silently forced ~90% of map generation attempts into the trivial fallback layout (2 rooms, no doors, no keys). The game appeared to work -- the fallback was completable -- but it gutted the intended difficulty arc. This class of bug is invisible during normal playtesting because the fallback masks the failure. Procedural generation with solvability gates needs adversarial testing of the generation path itself, not just the generated output.

The push-block puzzle specified a "lock after first push" safety rule in the design doc, but the developer never implemented it. The omission created a softlock vector that consumed iterations 2 and 3 — first discovered as a new MAJOR in iteration 2's QA, then mitigated (not fixed) by a room-exit reset in iteration 3. Puzzle mechanics with irreversible player actions need their safety constraints treated as core logic, not edge-case handling, because they are invisible until a player does the wrong thing.

The ambient drone fade bug survived two fix attempts across three iterations because the root cause was structural (updateDrone positioned after state-specific early returns in the game loop) but the first fix targeted symptoms (resetting droneTarget in startDrone). Partial fixes to audio lifecycle bugs pass smoke tests — the drone still played, it just never faded — making the regression invisible without explicit QA verification of the fade behavior in every non-PLAYING state.

The signature moment (first hostage pickup) was designed as the emotional core of the game, but the initial implementation cut its two key components -- the ascending audio sweep and the boarding animation -- as feasibility deviations. The result was a functional pickup mechanic that felt like a checkbox, not a rescue. It took a full polish iteration to restore what should have been protected during implementation.

A single missing state variable reset (`waveIndex` not zeroed on sector transition) made sectors 2 and 3 skip all waves and jump straight to the boss, erasing two-thirds of the game's content. The bug survived iteration 1's polish pass because QA and playtesting focused on sector 1 gameplay feel rather than verifying that all sectors played their full wave sequences. State resets on transitions need systematic verification against every variable that drives progression, not just the obvious ones like score and hull.

The ghost pen-exit bug -- ghosts stuck forever because the tile-center snap threshold exceeded per-frame movement distance -- was invisible to code-reading QA but caught immediately by the AI player agent actually running the game. Static analysis cannot detect mathematical relationships between runtime values (speed * dt vs. snap threshold) that only manifest during execution. This is the first game where the player agent caught a bug no other agent found.

Linear difficulty scaling formulas (e.g., 1 + d * 0.08) are mathematically correct but perceptually invisible within normal play sessions. The designer specified linear curves that looked reasonable on paper but produced a flat-feeling game for the first 90 seconds. It took until the iteration 2 polish pass to replace them with a power curve (d^1.4), which was the single highest-impact change across all iterations, moving Challenge from 3/5 to 4/5.

The art director added 505 lines (28% of the final game) and was the single biggest quality driver — thematic coherence hit 5/5 because every visual and audio layer reinforced the CRT arcade cabinet feel. Feasibility estimates account for art-director contributions via the 1.5x multiplier, but the multiplier treats art as overhead rather than as the primary differentiator it often is. When a game's creative direction depends on a specific aesthetic (CRT bloom, scanlines, sprite enhancement), the art pass is not polish — it is the game's identity.

The cascade mechanic was algorithmically trivial but the game shipped at 4/5 fun until visual polish (motion trails, chain-depth glow) made cascades feel like physical events rather than grid-state edits. Audio alone carried the signature moment for two full iterations -- the developer delivered correct mechanics but the feel spec's visual elements (trail, bloom) were deferred as stretch, leaving the game's namesake feature visually hollow.

Iteration 1 added three feel improvements (auto-hop, quota celebration, slow-mo timing fix) and each one introduced a major regression in the Level 10 special-case transition path -- hollow multi-fire, burst coordinate space mismatch, tab-switch canceling victory. All three regressions shared the same root cause: the L10 transition lacked a boolean guard from the start, so every new code path that touched it created a new failure mode. Special-case state transitions are regression magnets when they lack entry guards on first implementation.

State-carry-over bugs consumed all 3 iteration cycles. Four of the six MAJORs were flags or arrays (newHighScoreThisGame, seenTier, platform re-emergence target, waveClearBonusAwarded guard) that were set during gameplay but never reset on the MENU-to-WAVE_INTRO restart path. Worse, the iteration 2 polish additions (high score banner flag, tier-encounter tracking) themselves became the iteration 3 MAJORs -- the fix introduced the next bug because the developer added new state without adding its reset point.

High-speed entities (ghost eyes at 12 tiles/sec) can overshoot tile-center alignment thresholds, causing pathfinding decisions to never trigger. The 0.06-tile threshold was smaller than the per-frame step (~0.1 tiles at 60fps), so ~40% of sub-tile offsets produced ghosts that sailed past their decision point and traveled in a straight line indefinitely. Design specified the speed but feasibility never verified the alignment math would hold at that speed.

Audio state management was the dominant bug source across all three iterations — pause bleed, oscillator accumulation, buffer node leaks, propeller wash lifecycle, and rumble during paused states each surfaced in successive QA passes. The DEATH_ANIM + PAUSED interaction forced a stateBeforePause tracking pattern that should have existed from the start. Every iteration fixed audio bugs and every iteration revealed new ones hiding behind the last fix.

The game hit the 3-iteration hard cap because iteration 2's grayscale desaturation fix introduced a rendering order bug -- renderGameOverScreen() contained a redundant renderStars() call that painted unfiltered stars over the correctly filtered ones, defeating the very effect it just implemented. The developer added the grayscale filter to the render pipeline but did not audit all downstream render calls for redundant draws that would bypass the filter. Layered visual effects are fragile when render functions contain their own background draws.

The only MAJOR bug was continuous audio oscillators (engine drone, graveyard atmosphere) playing through tab-hide because the base template's visibilitychange handler pauses the RAF loop but does not mute AudioContext gain nodes. This is the same bug class that dominated Sea Wolf's iterations (entry #16). The template teaches developers to pause the game loop on hidden tabs but silently omits the audio half of the contract, so every game with continuous oscillators ships this bug until QA catches it.

The iteration 1 triage misread E17's {supplies:1} as a "+1 reward" when it was already the correct net value (-1 throw cost + 2 reward = +1 net). The "fix" to {supplies:2} introduced the game's only remaining bug -- a regression created by the fix itself. When iteration triage prescribes code changes based on spec-vs-code comparison, collapsed net values look like wrong rewards, and the fix breaks what was already correct.

The game's identity mechanic -- shockwave platform displacement -- was spec'd at SHOCKWAVE_FORCE=200 and implemented correctly, but the resulting 5-10 pixel platform slide was too subtle for players to notice. The core differentiator (bullets reshape space) was functionally invisible until a polish iteration doubled the force to 400. Designer verification scenarios confirmed the mechanic worked but could not catch that it did not read -- correctness is not legibility.

The cascade dying flag bug existed in two separate code paths (updateCascade and handleBallDrop's force-complete) but only the first was caught in the initial QA pass — the second was found during iteration 1 re-evaluation. When a state flag is set in multiple code paths, a fix to one path does not fix the others. This 'same bug, parallel paths' pattern is the most dangerous class of single-line bug because it passes targeted verification while the duplicate silently persists.

The GAME_OVER-to-MENU state transition was the sole source of bugs across both iterations. Iteration 1 fixed city data persistence (dark silhouettes on menu); iteration 2 fixed the same transition again because entity arrays (incomingMissiles, counterMissiles, explosions) were missed -- a piecemeal cleanup that was incomplete on the first pass. State-transition cleanup done incrementally guarantees a second bug for the same root cause.

Despite aggressive feasibility cuts (boss phases 3 to 2, formation bonus removed, ambient drone dropped, three unique attack patterns simplified) and the 1.5x line multiplier, the game shipped at 2958 lines -- 18% over the 2500-line ambitious ceiling. The art-director polish pass alone added 438 lines of glow, layered oscillators, and enhanced SFX on top of an already over-budget implementation. Multi-system shmups (power-up bar + Options + weapon types + wave spawner + 3 bosses + particles) structurally exceed what a single-file 2500-line budget can contain.

The player agent reported BLOCKED with zero deliveries across 11 attempts, which was a false positive caused by Playwright polling latency — not a game bug. This was triaged as a MAJOR, consumed investigation time across QA and developer, and the gameplay test strategy had to be refactored to work around the same timing issue. Games requiring precise real-time input (dodging vehicles in narrow gaps) expose a structural limitation in headless browser play testing.