The SLOPE Framework

AI coding agents lose context. They crash, compact, and restart. Without a fixed lifecycle, every session starts from zero — the agent has no idea what happened in the last 50 sprints.

SLOPE's lifecycle is designed around this constraint. Every artifact is written to disk at specific checkpoints: the sprint file after pre-round, the scorecard after post-hole, the handicap after the 19th hole. When context compacts, the agent reads these artifacts and picks up exactly where it left off.

The "for each ticket" loop is where most work happens. But the pre-round and post-hole routines are what make the data compound. Without them, you just have a git log. With them, you have a trajectory.

The five levels aren't arbitrary — they map to different feedback loop frequencies. A stroke (commit) gives you immediate feedback: does it compile? A shot (ticket) gives you end-of-task feedback: does the feature work? A hole (sprint) gives you multi-task feedback: did the team improve?

The round (phase) and tournament (project) levels are where strategic patterns emerge. "We always struggle at the mobile-orchestrator boundary" is a round-level insight. "Our scoping gets better every phase" is a tournament-level trend.

Most dev frameworks only operate at one or two levels. SLOPE gives you vocabulary and measurement at all five, so you can reason about performance at the right granularity.

A Par 4, Slope 3 sprint is meaningfully harder than a Par 4, Slope 0. Both have 3-4 tickets, but the slope factors compound difficulty in ways that ticket count alone doesn't capture.

The handicap system accounts for this: handicap = avg(score - par) over a rolling window. A bogey on a Slope 3 sprint is more forgivable than a bogey on Slope 0. The framework doesn't penalize you for taking on hard work.

Example: Sprint 167 — Par 4, Slope 2 (cross-package + schema migration)
Score: 5 (Bogey) — but given the slope, this is a solid result.
The handicap computation weights this appropriately.

Club selection isn't just metadata. It's a forcing function that makes you think about complexity before writing code. When you pick up a driver, you're saying: "this is risky, this is new, I'm swinging hard." When you pick up a putter, you're saying: "this is close to done, precision matters more than power."

Over time, club selection data reveals patterns: "We always reach for drivers on OAuth work, but irons would be safer." This is exactly how golf pros optimize — they know which clubs they hit consistently and which ones introduce variance.

The provisional is particularly powerful for AI agents. When an agent declares a provisional ("if this approach fails in 2 commits, switch to X"), it prevents the common failure mode of sinking 45 minutes into a dead-end approach.

The real power isn't in logging individual hazards — it's in the bunker location map that accumulates over time. After 50 sprints, you know exactly where the bunkers are: "the OAuth module always has nvm sourcing issues," "mobile-orchestrator boundary misses right on integration."

This map gets baked into the pre-shot routine. Before starting a ticket, the agent checks: "are there known bunkers in this area?" If yes, it budgets an extra shot and selects a safer club. This is how golf pros play — they don't just swing and hope. They study the course.

In CaddyStack, this is implemented as common-issues.json — a growing database of gotchas indexed by code area, severity, and recurrence. The pre-round briefing surfaces the top hazards for the sprint's work area automatically.

Conditions aren't excuses — they're context. A bogey in wind (context compaction) is different from a bogey on a calm day. The scorecard captures both the score and the conditions, so when you review your handicap trend, you can separate "bad play" from "hard conditions."

Pin position is especially useful for AI agents. A ticket with loose acceptance criteria ("make the UI better") is a center pin — easy to land near. A ticket with precise requirements ("the animation must be exactly 200ms with this easing curve") is a tucked pin — requires surgical precision. Knowing the pin position before you swing changes your club selection.

The #1 insight from 175 sprints: routine beats talent. An agent that follows the pre-shot routine every time will outperform an agent that's "smarter" but inconsistent. Golf pros know this — they don't skip their routine even when they're playing well.

The 19th Hole is the most underrated part. It captures what metrics can't: momentum, energy, intuition. After 50 sprints of 19th Hole notes, patterns emerge that no stat can show: "we always feel drained after OAuth work," "infrastructure sprints are energizing."

For AI agents specifically, the routines solve the context compaction problem. When an agent's context window fills up and old messages get compressed, the routine artifacts on disk preserve everything. The next session reads the sprint file and the scorecard, and it's as if no context was lost.

The handicap isn't a judgment — it's a prediction. A handicap of 1.2 means "this system averages 1.2 strokes over par." That's not bad or good in isolation — it's useful because it tells you what to expect from the next sprint.

The three windows (last 5, last 10, all-time) show different things:

• Last 5 — Are you in form right now? Recent momentum.
• Last 10 — Is this a trend or a fluke? Smooths out variance.
• All-time — Your baseline. Where you started vs where you are.

When last-5 is significantly better than all-time, you're improving. When it's worse, something changed — check conditions, check hazards, check if you're playing a harder course (higher slope sprints).

The miss pattern is arguably more actionable than the handicap itself. "We consistently miss long" means the team over-engineers. "We miss right" means the approach is correct but execution/integration fails. This directly maps to training drills: research sprints for "long" misses, feedback sprints for "right" misses.