Knowledge Compounds When Code Doesn't

Integration three took three days.

Not a fast three days - an honest three days, research and a merged PR. Same scope as the previous two: state machine, Lambda extraction pipeline, parsing layer, frontend adapter. Integration one had taken four weeks. Integration two, two weeks.

I've not spent those months getting faster at writing Lambda functions. The functions were already fast to write.

What compounded was everything else.

---

Three Partner integrations at a property tech SaaS over four months. Scope near-identical each time - an ETL of sorts, business logic layered on top. A translation layer and a business contract, wrapped in code.

• Integration 1: ~4 weeks. Greenfield. State machines, Lambda extraction pipeline, parsing layers, API client, frontend UI. Every decision was a new decision.
• Integration 2: 2 weeks. Same shape, different API. The constructs existed. The pipeline shape existed. New work was understanding this provider's quirks - auth model, pagination behaviour, field name mismatches, business logic.
• Integration 3: 3 days. The pattern so established the work was almost entirely "find the diff." Spike done as prep. Playbook in hand.

The first integration defined the dependency chain. By the third, it was already mapped to individual commits.

What actually compounds

1. The question shrinks.
Integration 1: "How do integrations work?"
Integration 2: "What's different about PropertyFoo compared to BarEstate?"
Integration 3: "What's BazAway's auth model - everything else is in the manual."

By integration 3, discovery is a checklist. Not fog of war.

2. Verified terminology.
By integration 2 you have shared vocabulary: what a "cycle" is, what "bootstrap" means (the event payload to kick off a fresh run), what "stuck" looks like in the logs vs. "healthy but slow." Terminology compresses the problem space. It also speeds up the prompting - not "find why our pipeline is slow, check the logs, compare with old runs... (and so on)" but "run the ingestion debug process." One phrase. Same result.

3. Runbooks.
Integration 1 produces incidents you don't know how to diagnose. By integration 3 you have a runbook: stuck vs. API down vs. Lambda timeout; the exact logging queries; the restart procedure. Every incident from integration 1 becomes a documented procedure by integration 3.

4. LLM infrastructure.
Each integration produces agent prompts, Cursor skills, investigation notes readable by the next session. The agent for a new integration references the existing pattern. It knows what "ingestion cycle" means. You don't explain it again.

Bash history is worth gold. Postman collections, APIs tested, full request/response dumps. I've been treating these as precious before - in an LLM world, they're the difference between hours and minutes.

5. The meta-pattern.
By integration 2 you know the shape of what you don't know yet. "I'll need to figure out whatever weird thing their API does with pagination - the OAuth flow is probably fine, rate limits are strict." Front-load discovery. The unknowns become a checklist.

How to structure the first one

Build a template, not an integration.
Structure it as a reference implementation from day one. Name it. Document what's generic vs. what's client-specific. Make the diff obvious so the next person - or the next you, or the LLM - can see what needs to change.

Write the runbook during the incident.
Every debugging session that produces a procedure is an opportunity while the context is live. Don't write it after - the next incident starts cold. Failure modes are specific and non-obvious, you won't reconstruct them cleanly from memory.

Name the compounding with the client.
"This integration will take two weeks. The next one will take one. Here's why." If they don't know compounding exists, they'll assume the second costs the same as the first - and wonder why you're not faster. Name it, price it, use it to your common benefit. There's no reason software can't offer a bulk discount.

---

Having smoothed it out to a few days of active work, the business unlocks real flexibility. A client can be closed in a week, not a month. Negotiations become a living thing - "I'll come back in a week with the numbers" - not a game of attrition.

And with an LLM? You train your dragon, then you soar.