Field Notes - Nov 7, '25

Executive Signals

Landing pages are the new MVP: ship value promises, measure pull before code
Proof over promises: data-on demos and pilots collapse AI skepticism
Narrow first, frictionless always: ICP fit then zero-onboarding activation wins fastest
Integrations are debt: limit surfaces, unify the long tail behind one API
Parallel epics slow teams : finish one surface, prove done, then expand
Sleeps hide bugs : event signals and time budgets keep bots honest

Investors de‑risk in sequence: founder obsession, team stability, early proof. Raise from customers first and treat equity as scarce. Show commitment with a killer demo, active usage, and at least one paid pilot before opening the deck.

Draft a personal “investment memo” (why you, market, timing)
Assemble proofs: demo video, ~10 weekly actives, ~3 LOIs, 1 paid pilot, role clarity
Prefer revenue to dilution until proofs stack

Gate Build With a Landing Page

Don’t fund code until the pitch converts. Ship a bare page that promises the outcome and measure qualified pull. Iterate message and offer until it clears a threshold, then build onboarding.

Require ≥20% CTA clicks on 100–200 qualified visitors before coding
Test 5–10 copy/offer variants weekly; capture email and “why now/why not”
Only fund onboarding once the page repeatedly clears the gate

Sales

Solve AI Skepticism With Proof, Not Promises

The market is noisy; trust comes from touchable outcomes. Lead with a data‑on demo that produces an artifact, follow with a generous trial, and secure a time‑boxed paid pilot to create commitment without procurement drag.

Offer a 14–30 day, high‑usage trial without feature gates
Script a 60‑minute, prospect‑data demo that outputs a real artifact
Price pilots modestly; publish privacy and guardrails up front

If HR Holds The Budget, It’s Sales‑Led

Bottoms‑up rarely closes when HR signs. Expect consensus buying, references, security reviews, and calendar‑bound procurement. If you want PLG, target managers with discrete budgets outside HR.

Arm buyers with hard ROI: time saved, attrition reduced, compliance passed
Staff for security review and procurement timelines
Aim PLG at budget‑owning managers, not HR

Product

Closest To The Customer Wins

Systematize discovery. Overweight live conversations, tag jobs‑to‑be‑done, and let repetition set the roadmap. When one ask dominates recency, ship exactly that and delete the rest.

Do 30–40 short calls weekly; record and tag every job
If ~70% mention one capability, build only that next
Re‑rank weekly; delete, don’t defer

Cut Your Integration Surface Area

Integration sprawl kills momentum. Use a unified‑API abstraction for breadth, and launch with only the connectors and domain that unlock one high‑value use case. Compound from a narrow, durable core.

Launch with two core connectors; add one per quarter based on active demand
Dominate one domain first (e.g., sales insights, compliance signals, CS risk)
Use a unified‑integration vendor for the long tail

Pick A Narrow ICP And Remove Adoption Friction

Early wins come from a segment you’ll serve for years. Filter for AI‑positive leaders and modern stacks, then make activation require no explanation.

Define three qualifiers (e.g., AI‑positive exec, modern chat, modern workspace)
Run ~40 ICP interviews in 7–10 days; turn repeats into v1
Enforce “qualify or decline” to protect speed

Engineering

Finish One Surface Before Expanding Scope

Split attention kills cycle time. Close the current surface to “done” with evidence before opening the next epic. “Done” means end‑to‑end, repeatable, and reviewed by a non‑author.

Freeze scope until live in target env with screens/logs attached
Define done: E2E runs, repeatable, non‑author approver review
Open the next epic only after clean handoff; no parallel epics

Codify Copilot Prompts That Reduce Latency

Treat AI assistance like code. Pair to find prompt patterns that move time‑to‑result, version them, and require provenance so wins persist.

Pair 45 minutes to ship 3+ micro‑refactors per adapter with deltas
Create “prompt cards” (before/after, prompt, delta) and link in PRs
Friday dump of new cards so Monday starts with proven patterns

Kill Dev‑Only Waits; Guard Real Waits

Most latency is self‑inflicted. Strip fixed sleeps, keep waits bound to real events, and parallelize adapters so one slow path doesn’t cap throughput.

Replace fixed sleeps with explicit event waits; cap defaults ~2s unless justified
Add a “silly‑wait audit”; instrument login‑to‑first‑input and E2E timings
Run adapters in parallel; optimize the top 20% driving 80% time

Fast‑Path Selectors, Event Signals, And Idempotence

Crawl becomes sprint when every action tries the deterministic path first, then a robust fallback only on miss. Wait on concrete signals, not “network idle,” and skip work that’s already done.

Try deterministic selector ≤500 ms; fallback on miss, log path taken
Prefer locator‑specific waits and API hooks; hard‑cap waits ≤3s without exception
Add “already‑selected” guards; cache handles and invalidate on navigation

Budgets And Drift Detection, Not Guesswork

Refactors without budgets drift. Enforce per‑step SLOs, capture artifacts on breach, and centralize selectors with nightly drift detection so fixes land once and propagate.

Instrument per‑action timings; fail merges on timing‑mode regressions
On budget breach: screenshot + minimal DOM dump; retry once via fallback
Centralize selectors in a typed registry; run nightly probes and version pins

Use Git Checkpoints, Not Agent “Undo”

LLM agents generate code, not state safety. Commit early and often, record prompts in commits, and review diffs like normal code to keep changes tractable.

Micro‑commit before big agent edits; squash later
Include “Prompt:” and “Intent:” in commit messages
Run pre‑commit tests/linters to catch breakage early