From 422772c9a2d4c60046c151fb19c97f000e804db7 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 5 May 2026 01:28:29 +0000 Subject: [PATCH] =?UTF-8?q?canon(6B):=20execute=20P0002=20=E2=80=94=20Bide?= =?UTF-8?q?=20as=206th=20B=20+=20Borrow=20Evaluation=20constraint=20+=20bo?= =?UTF-8?q?otstrap=20bullet?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Operator-authorized exception to the agent-canon-read-only rule in AGENTS.md. Authorization: operator directive 'Let's do 3/4' on 2026-05-05 in the recurrence-escalation conversation following AMS PR #33's hosted /mcp handroll (the sixth occurrence of the pattern P0002 documents). The default rule remains: agents do not write canon. This commit is the mechanical application of operator-accepted drafts (P0002 status: accepted 2026-05-05) to the three named target files. Per docs/promotions/README.md, this corresponds to the 'executed' step of the promotion lifecycle. THREE COORDINATED EDITS: Edit 1 — canon/methods/borrow-bend-break-beget-build.md - Frontmatter: title and # heading updated to 'Borrow, Bend, Break, Beget, Bide, Build'; tags add 6B, bide, strategic-patience, reversibility; epoch advanced E0005 -> E0008.5; date updated; complements adds the new constraint; supersedes_concept records the 5B->6B history. - Filename and URI retained for backward compatibility (renaming would break existing references). - Opening blockquote: extended to acknowledge Bide as deliberate strategic patience with a tripwire and inspection step. - Summary: 'Five Steps' -> 'Six Steps'; intro paragraph adds the strategic-patience concept; new closing paragraph names Bide's discipline and points at the agent-binding constraint. - The Sequence: new 'Bide — Wait for the Field to Build It For You, Then Inspect What Surfaces' subsection inserted between Beget and Build. Names the three resolution paths (waiting / inspected-and-adopted / inspected-and-rejected), the three required components (reason, tripwire, inspection step), the six inspection criteria for rejection, and the framing that both fork outcomes are success states. - Build subsection retitled to 'Only What Nobody Else Can Carry and What Waiting Cannot Resolve'. - Constraints section: 'borrow, bend, and beget' -> 'borrow, bend, beget, and bide'; new paragraph naming reversibility as a planning-time criterion the method requires consideration of. Edit 2 — canon/constraints/borrow-evaluation-before-implementation.md (NEW) - Tier-1 constraint, ~330 lines, semi_stable. - Operationalizes the 6B method as a falsifiable planning-mode artifact. - Includes: Goldratt frame, when the constraint binds, the six-row evaluation table with verdict vocabulary, what counts as a real Borrow vs. a real Bide, the six inspection criteria, operational sequence, what is forbidden, three worked examples (oddkit write layer adopted; AMS wire layer rejected-then-built-minimal; six MCP server failure shape), failure-mode table, risks and reversibility of the constraint itself, relationship to other canon, see-also. Edit 3 — canon/bootstrap/model-operating-contract.md - New bullet under 'Before Shipping Code' pointing at the new constraint. - Restates the rule's surface: six-row evaluation; named justifications; named criteria for rejected; tripwires for waiting; reversibility note; falsifiable, not ritual; explicit empirical base ('six times across six MCP server projects; do not be the seventh'). NOT INCLUDED: - P0002 status flip from 'accepted' to 'executed' — left to a follow-up PR after this PR merges and the canon-edit commit SHAs are stable, to avoid merge-order coupling with the in-flight PR #165 that touches P0002's frontmatter for the accepted-status flip. - Filename rename to 'borrow-bend-break-beget-bide-build.md' — declined to preserve URI continuity for existing references across canon and consumer projects. URI integrity: all internal references between the three files resolve at merge time. External references (ams://canon/constraints/mcp-build- side-governance) resolve once the companion AMS PR #35 merges. Reversibility: two-way. The 6B method's filename/URI are unchanged; the in-doc title and content are extensions, not rewrites. The new constraint is itself reversible per its own 'Risks and Reversibility' section. --- canon/bootstrap/model-operating-contract.md | 1 + ...borrow-evaluation-before-implementation.md | 238 ++++++++++++++++++ .../methods/borrow-bend-break-beget-build.md | 64 +++-- 3 files changed, 289 insertions(+), 14 deletions(-) create mode 100644 canon/constraints/borrow-evaluation-before-implementation.md diff --git a/canon/bootstrap/model-operating-contract.md b/canon/bootstrap/model-operating-contract.md index 409ca2a1..b8a287ca 100644 --- a/canon/bootstrap/model-operating-contract.md +++ b/canon/bootstrap/model-operating-contract.md @@ -88,6 +88,7 @@ The oddkit tools encode the discipline. They are not invoked on request — they - **`klappy://canon/constraints/release-validation-gate`** — Fetch and obey before merging any PR to `klappy/oddkit` (or any oddkit-pattern MCP server) and before promoting to prod. Defines the three binding rules; same-session smoke is not validation. - **`klappy://canon/principles/contract-governs-handoff-drift`** — Read when a session ledger or handoff recommends shortcutting a canon rule. Canon wins; propose amendment if the session's judgment was actually right. +- **`klappy://canon/constraints/borrow-evaluation-before-implementation`** — Fetch and obey before any implementation task with an upstream substrate (SDK, reference impl, widely-adopted library) — or one the field is visibly converging toward. Six-row 6B Evaluation in the plan; one verdict per row including the Bide verdicts (`waiting` / `inspected-and-adopted` / `inspected-and-rejected`); named justifications for skips; named criteria for `inspected-and-rejected`; tripwires for `waiting`; one-line Reversibility Note. Falsifiable, not ritual. The constraint exists because the same handroll has happened six times across six MCP server projects with the same operator; do not be the seventh. ### For Durable Records diff --git a/canon/constraints/borrow-evaluation-before-implementation.md b/canon/constraints/borrow-evaluation-before-implementation.md new file mode 100644 index 00000000..fd27b188 --- /dev/null +++ b/canon/constraints/borrow-evaluation-before-implementation.md @@ -0,0 +1,238 @@ +--- +uri: klappy://canon/constraints/borrow-evaluation-before-implementation +title: "Borrow Evaluation Before Implementation — A Falsifiable 6B Table the Agent Produces in Planning Before Any Implementation Execution" +audience: canon +exposure: nav +tier: 1 +voice: neutral +stability: semi_stable +tags: ["canon", "constraint", "governance", "6B", "borrow", "bide", "build", "preflight", "planning", "agent-execution", "theory-of-constraints", "ai-collaboration", "vision-fit", "reversibility", "anti-pattern"] +epoch: E0008.5 +date: 2026-05-05 +derives_from: "canon/methods/borrow-bend-break-beget-build.md, canon/constraints/mode-discipline-and-bottleneck-respect.md, docs/oddkit/proactive/proactive-preflight.md, canon/principles/dry-canon-says-it-once.md, docs/promotions/P0002-borrow-evaluation-before-implementation.md" +complements: "canon/methods/borrow-bend-break-beget-build.md, canon/bootstrap/model-operating-contract.md" +governs: "Any agent in planning mode about to execute an implementation task with an upstream substrate (SDK, reference impl, widely-adopted library) — or one the field is visibly converging toward. Binds the planning artifact: the agent must produce a falsifiable 6B Evaluation table plus a one-line Reversibility Note before execution begins." +status: active +--- + +# Borrow Evaluation Before Implementation — A Falsifiable 6B Table the Agent Produces in Planning Before Any Implementation Execution + +> The 6B method (`canon/methods/borrow-bend-break-beget-build`) is the meta-discipline. This constraint is the planning-mode operationalization that binds the agent. Before any implementation task that has an upstream substrate or that the field is visibly converging toward, the agent produces a six-row evaluation table — one verdict per B, named justifications for skips, named criteria for `inspected-and-rejected`, tripwires for `waiting` — plus a one-line Reversibility Note. The table is falsifiable and the operator can challenge any row. A blank checkbox does not satisfy this constraint; an aesthetic skip ("I want to understand it") does not satisfy this constraint. Skipping the evaluation entirely is a violation regardless of how the resulting code performs. + +--- + +## Why This Constraint Exists — The Goldratt Frame + +Stopping to do a Borrow Evaluation feels like overhead at the local station. It costs six lines of plan and one or two search round-trips. Local-throughput thinking treats this as drag. + +Theory of Constraints says the local throughput is not the system throughput. The system throughput is bounded by the operator's attention — the slowest, most expensive, most non-recoverable resource in the loop. Every handroll the agent performs without a Borrow Evaluation pulls the operator into: + +- Bugs the upstream community has already found, reported, fixed, regression-tested, and released. +- Spec drift between the handroll and the standard, discovered weeks later by an integration partner. +- Maintenance debt for code that becomes obsolete the day a free alternative ships — the cost the Bide step prevents. +- Adoption of an opinionated stack that forces architectural decisions outside the framework's proper scope — the cost the Bide *inspection* step prevents. +- The same explanatory conversation, repeated across sessions and projects, with no encoding that survives. + +The local "inefficiency" of producing the evaluation is the global efficiency of not paying any of those costs. This is the same logic that justifies the inspection step in lean manufacturing: the line stops to inspect because the cost of catching a defect at the source is orders of magnitude lower than the cost of catching it downstream. + +Per `canon/principles/dry-canon-says-it-once` applied to operator attention: the same handroll-correction conversation must not happen twice. Six occurrences of the same conversation across six MCP server projects is the empirical disproof that "the rule exists in canon" is sufficient without a planning-mode artifact that surfaces it. + +--- + +## When This Constraint Binds + +The constraint binds whenever **any one** of these triggers fires in planning: + +- The implementation target is a standardized protocol or interface with a maintained reference SDK from the protocol authors (e.g. `@modelcontextprotocol/sdk` for MCP, `@cloudflare/agents` for Workers-hosted MCP). +- The implementation target is a category of integration where a widely-adopted library exists (e.g. HTTP clients, SQL query builders, JSON schema validators, OpenAPI codegen). +- The implementation target is something the field is visibly converging toward (multiple parties shipping, reference impls in flight, clear emergence window). +- The implementation target was previously implemented in any other project in the same organization, with patterns or libraries that could be lifted. + +If none of these triggers fire, the constraint is inert for that task. The agent records the absence of triggers in the plan; this is not a silent skip. + +--- + +## What the Agent Must Produce + +A six-row table in the plan, one row per B in the 6B sequence: + +| Step | Verdict | Justification (required when verdict is `skipped` or `rejected`) | +|-----------|-----------------------------------------------------------------------------------------|------------------------------------------------------------------| +| Borrow | `applied` / `skipped` / `n/a` | Named upstream artifact + version; or named reason for skip | +| Bend | `applied` / `skipped` / `n/a` | What was bent and how; or named reason for skip | +| Break | `observed` / `none-yet` / `n/a` | Specific friction observed in Borrow/Bend; or "no friction yet" | +| Beget | `delegated` / `skipped` / `n/a` | Who is carrying the piece; or named reason for skip | +| Bide | `waiting` / `inspected-and-adopted` / `inspected-and-rejected` / `n/a` / `skipped` | Tripwire (for `waiting`); inspection target + criterion (for `rejected`); named reason for `skipped` | +| Build | `none` / `minimal` / `not-yet` | What was built; trace to the specific Break that demanded it | + +Plus a one-line **Reversibility Note** in the form: + +> Reversibility: forward = [low | medium | high]; backward = [low | medium | high]. [Optional one-clause rationale.] + +The note records the asymmetric swap-cost in either direction. It is one line; it is not a section. + +--- + +## What Counts as a Real Borrow vs a Real Bide + +A **Borrow** is real when: + +- A specific named upstream artifact (package, library, repo, version) is identified. +- The artifact is used as-is or with the documented Bend pattern. +- The agent records the package in the dependency manifest and uses its public API. + +A Borrow is NOT real when: + +- The agent says "I considered the SDK" without naming it. +- The agent imports the SDK but reimplements its core functionality alongside. +- The agent forks the SDK to make trivial modifications instead of contributing upstream or using the documented extension points. + +A **Bide** is real when: + +- A specific named gap is identified: "X does not yet exist; it appears the field is heading toward it via [project A], [project B], [project C]." +- A reason the wait is acceptable is named (urgency, scope, fallback availability). +- A tripwire is set: a date, a milestone, a condition that triggers re-evaluation. +- An inspection step is committed to: when the tripwire fires, what surfaces is evaluated against the named criteria. + +A Bide is NOT real when: + +- The requirement is forgotten about, with no record. +- The agent vaguely hopes someone else will solve it. +- Indefinite deferral with no tripwire. +- Bide is used as a way to avoid a hard problem that genuinely must be solved now. +- Reflexive adoption of whatever the field surfaces, without inspection. + +If the Bide has no tripwire, it is not a Bide; it is dropped scope. Drop it explicitly or set the tripwire. If the wait completes and the inspection is skipped, the Bide is also incomplete. + +--- + +## The Inspection Criteria + +A `Bide → inspected-and-rejected` verdict requires naming **which** inspection criterion applied and **what specifically** was inspected. The criteria — any one of which justifies rejection followed by `Build = minimal` — are: + +- **Vision conflict.** What surfaced makes architectural choices that conflict with the project's vision or foundational needs. +- **Foundational gap.** What surfaced sits above the layer where the foundational need lives, leaving the underlying problem unaddressed. +- **Gross overcomplication.** What surfaced solves a much larger problem than the one at hand and brings the cost of that scope along. +- **Opinionated stack imposition.** What surfaced requires adopting a particular runtime, framework, language, or topology that forces decisions outside the framework's proper scope. +- **Improper authority.** What surfaced makes architectural or product decisions that are not its place to make — decisions that belong to the operator or to the layer above. +- **Persistent gap after multiple field iterations.** What surfaced addresses adjacent problems but consistently fails to close the specific gap, and waiting longer has diminishing returns. + +A bare "didn't fit" is not a verdict; it is an aesthetic skip. The named criterion plus what specifically was inspected (named libraries, repos, versions) is the minimum bar. + +--- + +## Operational Sequence in Planning + +1. **State the implementation goal in one sentence.** +2. **List the candidate upstream substrates** (SDK, library, spec, reference impl, near-future field convergence pattern). Two minutes of search, not a survey. +3. **Run the 6B Evaluation table** above, one row per step. Be specific — name versions, repo URLs, package names, expected emergence windows, inspection results. +4. **Add the one-line Reversibility Note.** +5. **Surface the table and note in the plan** the operator can see (or in the plan record for solo runs). +6. **If `Build = minimal`, that is the only thing scoped for execution.** Anything beyond it is scope creep and triggers reversion to planning. + +--- + +## What This Forbids + +The following are violations regardless of how the resulting code performs: + +- Writing implementation code in execution mode without a Borrow Evaluation present in the plan. +- Marking `Borrow = skipped` or `Bide = skipped` without a named justification on the same line. +- Treating "I'll just write a quick version" as a Build verdict — that is the local-maximum trap, not a justification. +- Re-implementing transport, framing, capability negotiation, message envelope, or lifecycle for a protocol whose authors ship a maintained SDK. +- Padding the evaluation with `n/a` to satisfy the form. The evaluation is falsifiable; the operator can challenge any row. +- Declaring a Bide without a tripwire. Bide-without-tripwire is dropped scope wearing a costume. +- Marking `inspected-and-rejected` without naming which inspection criterion applied and what specifically was inspected. +- Skipping the Reversibility Note. The note is one line; absence is not brevity, it is an omission. + +--- + +## Worked Examples — Both Fork Outcomes Are Success States + +**Success case 1 — `Bide → inspected-and-adopted`: oddkit's write layer.** + +| Step | Verdict | Justification | +|-----------|------------------------------------|---------------| +| Borrow | `n/a` | No upstream connector existed at the time | +| Bend | `n/a` | Nothing to bend | +| Break | `observed` | Manual integration was required for every new AI tool target | +| Beget | `skipped` | No party was positioned to build it generically | +| Bide | `inspected-and-adopted` | Tripwire: emergence of native MCP connectors across major AI tools (GitHub MCP server as the leading indicator). Fallback during wait: humans as the manual wire/bus. Tripwire fired Jan 2026; inspection passed (vision aligned, no foundational gap, no overcomplication, no improper authority); adopted. | +| Build | `none` | The Bide adoption obviated the build | + +Reversibility: forward = low (adoption is reversible by un-adopting the connector); backward = low (manual fallback was the bide-time mode and remains available). + +**Success case 2 — `Bide → inspected-and-rejected → Build = minimal`: agent-messaging-service wire layer.** + +| Step | Verdict | Justification | +|-----------|------------------------------------|---------------| +| Borrow | `applied` | MCP, A2A, ACP, NLIP, AMP, ANP — all 2025–2026 agent-comms cluster entrants | +| Bend | `applied` | Composed against AMS use cases (two-agent conversations, polymorphic subscribers) | +| Break | `observed` | Each entrant bundles identity, capability schema, transport, payload format into one envelope at a particular altitude — the bundling is the substrate property AMS refuses | +| Beget | `n/a` | No party was positioned to build a substrate that refuses these opinions | +| Bide | `inspected-and-rejected` | Tripwire: ongoing observation of the cluster. Inspection criteria applied: opinionated stack imposition (envelope altitude), improper authority (each entrant takes architectural authority that belongs above), foundational gap (none address the dumb-pipe broker layer), persistent gap (multiple iterations across the cluster have not closed the gap). Rejection justifies Build by exclusion. | +| Build | `minimal` | The AMS wire is approximately 250 lines of Conversation DO logic — the smallest thing that delivers stream-by-stream broadcast with structurally-excluded self-delivery | + +Reversibility: forward = high (the AMS wire is now a substrate with downstream dependencies); backward = high (re-adopting an opinionated cluster entrant would require migrating all consumers off the wire's contract). Reversibility cost is documented; the chosen path is the long-term commitment the project knowingly made. + +**Failure case — Borrow silently skipped (six MCP server projects):** + +| Step | Verdict | Justification | +|-----------|------------------------------------|---------------| +| Borrow | `skipped` | (no justification recorded — this is the violation) | +| Bend | `n/a` | (no Borrow to bend) | +| Break | `n/a` | (no friction observed because no Borrow was attempted) | +| Beget | `skipped` | (no recorded reason) | +| Bide | `skipped` | (no recorded reason) | +| Build | `done` | Custom JSON-RPC handroll, ~1000 lines, reimplements what `@modelcontextprotocol/sdk` or `@cloudflare/agents` McpAgent provides | + +Reversibility: not addressed. (Absence is the violation.) + +This row, repeated across six MCP server projects with the same operator, is the empirical disproof that the meta-method alone is sufficient. The agent-binding planning-mode form — this constraint — is what closes the loop. + +--- + +## Failure Modes and Mitigations + +| Failure mode | What it looks like | Mitigation | +|----------------------------------------------------------------|-------------------------------------------------------------------|------------| +| Evaluation produced after execution begins | The table appears in the PR description, not in the plan | Preflight surfaces this constraint; the gate to execution requires the table to be present in the plan | +| Padded `n/a` rows | All rows marked `n/a` to satisfy the form | Operator can challenge any row; `n/a` requires the absence-of-trigger justification | +| Aesthetic skip dressed as criterion | "Didn't fit" or "felt heavy" cited as `inspected-and-rejected` | The criterion must be named (one of six); what was inspected must be named (specific library, version) | +| Bide without tripwire | `waiting` with no date, milestone, or condition | Bide-without-tripwire is dropped scope; the rule rejects the row | +| Reversibility Note missing | The one-line note is absent | The constraint requires the note; absence is a violation | +| SDK adopted as a check-the-box, then the agent reimplements alongside | SDK in dependencies, but the SDK's core path is duplicated locally | Borrow is real only when the agent uses the SDK's public API as the primary path | + +--- + +## Risks and Reversibility of This Constraint Itself + +**Risk 1 — Evaluation becomes ritual rather than substantive.** Mitigated by falsifiability: the operator can challenge any row, and rows that fail challenge invalidate the evaluation. A blank checkbox does not satisfy. + +**Risk 2 — The constraint blocks legitimate handrolls.** Mitigated by the `inspected-and-rejected → Build = minimal` path. The rule does not forbid handroll; it forbids *unjustified* handroll. The AMS wire is the worked example: a justified Build is canon-compliant. + +**Risk 3 — The constraint adds planning friction without benefit.** Mitigated by the empirical base: six handroll recurrences across six MCP server projects, plus the explanatory cost compounded across each. The friction the constraint adds is bounded; the friction it avoids is unbounded. + +**Reversibility of this constraint.** This rule is itself reversible. If the constraint is observed to produce rituals more than insight, or to block more legitimate Builds than it prevents sloppy ones, it is updated via canon revision. The disconfirmer is named: empirical evidence across multiple projects that the evaluation either stops surfacing real choices or systematically rejects substrates that turn out to be the right answer. + +--- + +## Relationship to Other Canon + +- `canon/methods/borrow-bend-break-beget-build` — the meta-method this operationalizes. The 6B method explains *why*; this constraint enforces *when and how*. +- `canon/constraints/mode-discipline-and-bottleneck-respect` — locates the evaluation in planning, where questions are cheap, not execution, where they collapse the bottleneck. +- `docs/oddkit/proactive/proactive-preflight` — the existing preflight rhythm. The Borrow Evaluation is a required output of preflight when an implementation trigger is present. +- `canon/principles/dry-canon-says-it-once` — applied to operator attention: the same handroll-correction conversation must not happen twice. +- `canon/bootstrap/model-operating-contract` — the bullet under "Before Shipping Code" surfaces this rule on first turn of every session. + +--- + +## See Also + +- `klappy://canon/methods/borrow-bend-break-beget-build` +- `klappy://canon/constraints/mode-discipline-and-bottleneck-respect` +- `klappy://canon/defaults/iteration-bias` +- `klappy://canon/principles/dry-canon-says-it-once` +- `klappy://docs/oddkit/proactive/proactive-preflight` +- `klappy://docs/promotions/P0002-borrow-evaluation-before-implementation` +- `ams://canon/constraints/mcp-build-side-governance` — the AMS-local manifestation of this rule for AMS MCP wrappers specifically diff --git a/canon/methods/borrow-bend-break-beget-build.md b/canon/methods/borrow-bend-break-beget-build.md index 42bbf8ac..531721ab 100644 --- a/canon/methods/borrow-bend-break-beget-build.md +++ b/canon/methods/borrow-bend-break-beget-build.md @@ -1,34 +1,37 @@ --- uri: klappy://canon/methods/borrow-bend-break-beget-build -title: "Method: Borrow, Bend, Break, Beget, Build" +title: "Method: Borrow, Bend, Break, Beget, Bide, Build" audience: canon exposure: nav tier: 2 voice: neutral stability: stable -tags: ["canon", "methods", "5B", "borrow", "bend", "break", "beget", "build", "leverage", "delegation"] -epoch: E0005 -date: 2026-02-15 +tags: ["canon", "methods", "6B", "5B", "borrow", "bend", "break", "beget", "bide", "build", "leverage", "delegation", "strategic-patience", "reversibility"] +epoch: E0008.5 +date: 2026-05-05 derives_from: - odd/constraint/use-only-what-hurts.md - canon/values/trust-kernel.md -complements: "canon/methods/self-audit.md, canon/methods/weighted-relevance-and-arbitration.md" +complements: "canon/methods/self-audit.md, canon/methods/weighted-relevance-and-arbitration.md, canon/constraints/borrow-evaluation-before-implementation.md" +supersedes_concept: "5B (Borrow, Bend, Break, Beget, Build) — Bide added as the sixth B per klappy://docs/promotions/P0002-borrow-evaluation-before-implementation; URI and filename retained for backward reference" --- -# Method: Borrow, Bend, Break, Beget, Build +# Method: Borrow, Bend, Break, Beget, Bide, Build -> The canonical sequence for maximizing work not done. Before building anything yourself, attempt to borrow what exists, bend it to your context, and let the breaks reveal what's missing. When something is missing, beget it — offload it to others who can own that piece and build it in parallel, even imperfectly. Only build yourself what nobody else can carry. The epistemic ledger is what makes this sequence compound — without it, each step starts from zero. +> The canonical sequence for maximizing work not done. Before building anything yourself, attempt to borrow what exists, bend it to your context, and let the breaks reveal what's missing. When something is missing, beget it — offload it to others who can own that piece and build it in parallel, even imperfectly. When the field is visibly converging toward a substrate that doesn't exist yet but probably will, **bide** — wait for it to surface, with a tripwire and an inspection step. Only build yourself what nobody else can carry and what waiting cannot resolve. The epistemic ledger is what makes this sequence compound — without it, each step starts from zero. ----- -## Summary — Five Steps That Progressively Narrow What You Must Build Yourself +## Summary — Six Steps That Progressively Narrow What You Must Build Yourself -Most premature building happens because people skip straight from idea to construction. They don't inventory what exists, don't test whether existing tools can be repurposed, don't let friction reveal what's genuinely missing, and don't consider whether someone else could own the missing piece. +Most premature building happens because people skip straight from idea to construction. They don't inventory what exists, don't test whether existing tools can be repurposed, don't let friction reveal what's genuinely missing, don't consider whether someone else could own the missing piece, and don't consider whether *waiting* — strategic patience with an inspection step — would let the field deliver what's missing without further investment. This sequence forces progressive narrowing. Each step reduces the surface area of what you must build yourself. The result is maximum leverage with minimum original work — which directly serves the agile principle of maximizing the amount of work not done. The sequence depends on the epistemic ledger. Decisions and constraints from earlier steps must persist into later steps without relying on human memory or conversation history. Without the ledger, the sequence collapses to "just build." +The sixth step — Bide — is the operationalization of *strategic patience with inspection*. It is not "do nothing." It carries its own discipline: a tripwire that forces re-evaluation, and an inspection step against named criteria when the wait completes. A Bide that is skipped silently is not a Bide; it is a Build masquerading as a sequence step. See `klappy://canon/constraints/borrow-evaluation-before-implementation` for the agent-binding planning-mode form of this method. + ----- ## The Sequence @@ -59,11 +62,42 @@ This is a deliberate act of delegation and trust. The output may not be exactly This is risky. You're depending on someone else's execution and timeline. You have to mitigate that risk — stay aware of whether the dependency is on track, have a fallback if it stalls, and accept imperfection in exchange for parallel progress. But in an AI-augmented world, this kind of collaboration is more plausible than it used to be. The cost of parallel work has dropped dramatically. The old pains of coordination that made it easier to just do it yourself are less prohibitive than they were. -If nobody can carry the piece, you move to Build. But beget first. Always. +If nobody can carry the piece, you move to Bide. If waiting is not an option, you move to Build. But beget first. Always. + +### Bide — Wait for the Field to Build It For You, Then Inspect What Surfaces + +When the missing piece is something the field is visibly converging toward — a category of tooling that multiple parties are converging on, a standardized protocol with reference implementations in flight, a substrate that the underlying ecosystem will likely supply within a knowable window — bide. Deliberately wait. Do not build, do not beget, do not silently drop the requirement; declare a Bide with the discipline that distinguishes patience from forgetting. + +A Bide MUST carry three things: + +- **A reason the wait is acceptable.** Urgency, scope, or the existence of a manual fallback during the wait. Without a reason, this is not a Bide; it is dropped scope. +- **A tripwire.** A date, a milestone, or a condition that triggers re-evaluation. Bide-without-tripwire is dropped scope wearing a costume. +- **An inspection step when the wait completes.** What surfaced is evaluated against named criteria, not adopted reflexively. + +A Bide resolves to one of three terminal paths: + +- **`waiting`** — the tripwire has not fired; the bide is active; a fallback is in place during the wait. +- **`inspected-and-adopted`** — the tripwire fired, what surfaced was inspected, the inspection passed; adopt and exit the sequence with `Build = none`. +- **`inspected-and-rejected`** — the tripwire fired, what surfaced was inspected, the inspection failed against at least one named criterion. The Bide is closed; proceed to Build, with the rejection's named criteria as the justification for `Build = minimal`. -### Build — Only What Nobody Else Can Carry +The inspection criteria — any one of which justifies `inspected-and-rejected` — are: -Now build. But only what genuinely could not be borrowed, bent, or begotten. The build should be minimal — the smallest thing that relieves the observed constraint and that no one else was able to take on. +- **Vision conflict.** What surfaced makes architectural choices that conflict with the project's vision or foundational needs. +- **Foundational gap.** What surfaced sits above the layer where the foundational need lives, leaving the underlying problem unaddressed. +- **Gross overcomplication.** What surfaced solves a much larger problem than the one at hand and brings the cost of that scope along. +- **Opinionated stack imposition.** What surfaced requires adopting a particular runtime, framework, language, or topology that forces decisions outside the framework's proper scope. +- **Improper authority.** What surfaced makes architectural or product decisions that are not its place to make — decisions that belong to the operator or to the layer above. +- **Persistent gap after multiple field iterations.** What surfaced addresses adjacent problems but consistently fails to close the specific gap; further waiting has diminishing returns. + +A bare "didn't fit" is not a verdict; it is an aesthetic skip. The named criterion plus what specifically was inspected (named libraries, repos, versions) is the minimum bar. + +A Bide that resolves to `inspected-and-rejected` justifies Build by exclusion. A Bide that is skipped does not. Both `inspected-and-adopted` and `inspected-and-rejected → Build = minimal` are correct outcomes of the same disciplined fork; treating one as the "main" path and the other as a "fallback" misframes the rule. Build after a documented rejection is the rule's correct answer for that case. + +If the wait is too costly, fallback unavailable, or the tripwire has fired without anything surfacing to inspect, you move to Build with the bide's outcome on record. + +### Build — Only What Nobody Else Can Carry and What Waiting Cannot Resolve + +Now build. But only what genuinely could not be borrowed, bent, begotten, or bidden. The build should be minimal — the smallest thing that relieves the observed constraint and that no one else was able to take on and that waiting was not going to resolve. If you find yourself building more than what the breaks demanded and the beget step couldn't cover, you're doing too much. @@ -73,12 +107,14 @@ After building, the cycle may restart. The new thing you built becomes something ## Constraints — What This Method Requires -You may not build before you have attempted to borrow, bend, and beget. The sequence is not optional — it prevents premature construction and solo heroics. +You may not build before you have attempted to borrow, bend, beget, and bide. The sequence is not optional — it prevents premature construction and solo heroics. A Bide that resolves to `inspected-and-rejected` justifies Build by exclusion; a Bide that is skipped does not. -What you build must trace to a specific break that was observed, not imagined, and that could not be offloaded to someone else. +What you build must trace to a specific break that was observed, not imagined, that could not be offloaded to someone else, and that waiting was not going to resolve. The ledger must travel with the work. Without it, continuity is lost across the sequence and each step starts from zero. +**Reversibility is a planning-time criterion that the method requires consideration of.** The cost of swapping out of the chosen path later, in either direction — adopt-then-leave or wait-then-build — must be surfaced at the planning layer. High forward cost (Build is sticky once chosen, especially for substrate-class artifacts) argues for more Bide patience and tighter `Build = minimal` discipline. High backward cost (Bide creates lock-in to a manual fallback that would be hard to undo) argues for shorter Bide tripwires and earlier Build with a clean interface. Reversibility cost is asymmetric and per-application; it is surfaced as a one-line Reversibility Note alongside the 6B Evaluation table per `klappy://canon/constraints/borrow-evaluation-before-implementation`. + This method is domain-agnostic. It applies to writing, development, product creation, translation, and any collaborative work governed by ODD. -----