AI Usage

Codebase & System Analysis

Used AI to scan and analyze the project requirements and constraints.

Process: Fed the task document to Cursor, asked it to identify:

• • Unclear requirements that needed clarification
• • Performance bottlenecks to consider (200 RPS, sub-200ms p95)
• • Trade-offs between different architectural approaches
• • Risks in the implementation plan

Generated local _temp/ .md files with TODOs, risks, and decisions. These became the foundation for GitHub issues or implementation tasks.

Prompt Iteration as a First-Class Step

Before implementing complex features, used ChatGPT to refine prompts.

Example: When designing the personalization scoring algorithm:

• • Started with vague prompt: "build a feed scoring system"
• • Iterated in ChatGPT to clarify: recency weights, category preferences, decay functions
• • Final prompt to Cursor included constraints, edge cases, and specific scoring formulas

Result: First implementation was 80% correct vs. typical 40% with rushed prompts.

Visual Thinking & Documentation

Created structured documentation pages before implementation to reason about the system.

Workflow:

• • Asked AI to generate architecture flow diagrams (using React Flow)
• • Built data model ERD visualizations before writing schemas
• • Used these visuals to spot missing relationships and circular dependencies

Documentation wasn't an afterthought—it was a design tool. Writing it clarified thinking.

Pair Programming & Strategic Focus

AI acted as a pair programmer. Human focused on architecture; AI handled execution.

Division of labor:

AI didn't make irreversible decisions. It executed on decisions that were already made.

Challenging Assumptions

Actively asked the LLM to critique proposals and identify flaws.

Example conversation:

This feedback prevented a major architectural mistake before any code was written.

Edge Case Simulation

Used LLM to simulate failure modes and unusual scenarios.

Questions asked:

• • "What happens if a user has no view history?"
• • "How does scoring behave with 10,000 stories vs. 10 stories?"
• • "What if all stories are from one publisher?"
• • "What breaks if the cache is cold?"

Answers informed default values, fallback logic, and safeguards in the implementation.

Documentation & Commits

Let AI handle commit messages and documentation—low-risk, high-repetition work.

Rationale: Writing good commit messages takes mental energy. AI can do this competently without supervision. Frees human time for higher-leverage decisions.

Still reviewed outputs—occasionally AI missed context or wrote vague messages—but 90% were good enough as-is.

"Chat With the Codebase"

Used AI as a fast context-reconstruction layer when working across multiple files.

Use case:

• • "Where is the personalization scoring actually applied?"
• • "What does the calculateScore function assume about input data?"
• • "Which routes use the cache middleware?"

Faster than grepping through files manually when context is fragmented or comments are sparse.

Risk Assessment & Irreversibility

Before committing to architectural decisions, asked AI to identify risks and irreversible choices.

Example: When deciding on the data model:

Risk analysis became part of development, not a post-mortem.

Parallelization of Tasks

Used multiple AI agents working on parallel tasks to avoid idle time waiting for sequential completion.

Approach: When tasks were independent, spun up parallel conversations with AI to work on multiple components simultaneously without overlap.

Examples:

• • One agent building the prototype API while another created documentation pages
• • One agent designing data schemas while another worked on the rollout plan
• • One agent implementing feed endpoints while another built UI components

Result: Tasks that would take 10+ hours sequentially were compressed into 4-5 hours of wall-clock time. Human coordinated the parallel streams and integrated outputs, but didn't sit idle waiting for one task to complete before starting the next.

Heavy Lifting

AI handled the majority of implementation work.

Honest assessment:

• • ~85% of code was AI-generated
• • ~10% was AI-generated then modified by human
• • ~5% was written entirely by human (specific edge cases, test validation logic)

Human focus was on steering strategic direction and creating tests to ensure everything works as it should. The mechanical work—boilerplate, routes, components, schemas, documentation—was almost entirely AI.

This distribution worked because human effort went into high-leverage activities: architectural decisions, test coverage, and validation. AI executed the plan.