Skip to content

ACKNOWLEDGEMENTS.md

Latest commit

 

History

History
77 lines (51 loc) · 11.9 KB

ACKNOWLEDGEMENTS.md

File metadata and controls

77 lines (51 loc) · 11.9 KB
Raw

Acknowledgements

abcd sits at the intersection of three movements: AI-assisted development tooling, product framing (working-backwards), and structured agent orchestration. Many projects, tools, and methodologies influenced or share design DNA with abcd. This page splits them into two kinds:

  • Inspirations — ideas, methodologies, and frameworks whose thinking shaped abcd's design but which abcd doesn't run, install, or interoperate with directly.
  • Concrete implementations — tools abcd actually depends on, calls into, or ships compatible with. Some are required at runtime; others are recommended integrations.

abcd doesn't replace any of the tools, frameworks, or methodologies it draws from. As a meta-framework, abcd sits on top of an AI coding runtime, beside plan-first orchestration, and adjacent to context-injection systems and product-framing methodologies. The differentiator is the brief / intents / delivered-reality structure with product thinkers (domain experts) in mind.

Inspirations

Product framing and intent

  • Amazon's Working Backwards — the press-release-as-spec methodology. PR/FAQ before engineering. abcd's intent format derives from this directly.
  • Architecture Decision Records (ADRs) — the practice of capturing why alongside what. abcd extends this principle across briefs, intents, and specs.
  • OpenAPI / Swagger — API-first design as a precedent for "describe the contract before writing the code."
  • GitHub Spec Kit — spec-driven workflow for AI-assisted development. abcd takes a different stance (intent-driven, not spec-driven) but the lineage is shared. The /speckit.clarify and /speckit.checklist patterns are the direct precursors to abcd's cite-or-fail lint mechanism: /speckit.clarify establishes the discipline of blocking on ambiguity before engineering; /speckit.checklist provides the per-criterion checklist pattern that abcd's acceptance-criteria lint adopts.

Acceptance criteria and requirements methodology

  • EARS — Easy Approach to Requirements Syntax (Mavin et al. 2009, Cockburn-cited) — structured natural-language patterns for acceptance criteria (WHEN <precondition>, the system SHALL <response>). abcd's grill skill rewrites vague acceptance criteria into EARS form during Phase 1 interrogation to make acceptance observable and testable.
  • Socratic moves in AI-assisted learning — Chang et al. (2023) — six named pedagogical moves for LLM-driven Socratic dialogue: Definition, Elenchus, Dialectic, Maieutics, Counterfactual, Generalization. These are the six named moves tagged on every grill question in grill-report.json; the enum is closed and validated by socratic-move-enum.json. The move names are cited directly from this paper's taxonomy.

Domain language and bounded contexts

  • Domain-Driven Design — Eric Evans (2003) — the ubiquitous-language principle: a shared, precise vocabulary within a bounded context. abcd's terminology/ glossary structure (one-file-per-term with bounded_context: frontmatter) is a direct application of the DDD bounded-context pattern to the intent stage. The cite-or-fail lint enforces ubiquitous language at promotion time.
  • BoundedContext — Martin Fowler — canonical web reference for the bounded context pattern. abcd's multi-context term handling (the same English noun with different definitions under core/ vs interview/ contexts) follows Fowler's formulation.

Multi-agent orchestration

  • LangGraph — graph-based agent orchestration. abcd's pass A/B/C design is conceptually similar (named stages with typed inputs/outputs).
  • CrewAI — role-based multi-agent framework. abcd's agent catalogue takes a similar role-based stance, though narrower in scope.
  • AutoGen — Microsoft's multi-agent conversation framework.

Pair-programming and adjacent tools

  • Aider — pair-programming-with-AI from the terminal. Different model (in-place editing vs. orchestrated agents) but overlapping audience.
  • Continue — open-source AI coding assistant with custom prompt and rule support.
  • Cody (Sourcegraph) — code intelligence + AI; precedent for repo-aware agent workflows.

Concrete implementations and planned integrations

Runtime and SDK

  • Claude Code — the CLI agent runtime abcd ships as a plugin for. Provides hooks, skills, slash commands, MCP integration. Currently required.
  • Anthropic Agent SDK — the underlying SDK Claude Code is built on; abcd's harness shim leaves room to port to other SDK consumers.
  • OpenCode — open-source agent harness with similar shape to Claude Code. abcd aims to be compatible with OpenCode in a later version.

Plan-first orchestration

  • flow-next — Plan-first AI workflow plugin. Task tracking, worker subagents, Ralph autonomous mode, cross-model reviews. abcd builds on top of flow-next directly: /abcd:intent plan calls into /flow-next:plan, and /abcd:intent ship calls /flow-next:work. Required.
  • PAUL (Plan-Apply-Unify Loop) — Project orchestration framework with mandatory closure ("every plan closes with UNIFY") and BDD acceptance criteria. abcd adopts the patterns (acceptance-first, escalation statuses) into its own primitives. Under consideration.

Context, memory, and rule injection

  • RepoPrompt — context-curation IDE; abcd's preferred oracle backend and a key inspiration for the "brief / context / chat" three-layer separation. Recommended.
  • SpecStory — conversation capture for Claude Code and other agents. Records every session as a structured Markdown transcript in .specstory/ that abcd consumes. Strongly Recommended.
  • Stoa — multiplayer workspace where teams and agents share specs, decisions, and AI conversations. Workspace product (not framework), but the specs-and-decisions-as-project-memory thread aligns with abcd's brief / intent / spec structure. Strongly Recommended.
  • CARL (Context Augmentation & Reinforcement Layer) — just-in-time context injection: domain-keyed payloads loaded on prompt-keyword recall instead of a monolithic CLAUDE.md. CARL's recall engine drives two payloads — procedural rules and a decision/memory layer — and brackets injection by remaining context window. abcd adopts the engine into its own plugin twice: itd-3's modular-rules-loader takes the rule payload (hook + JSON + recall + dedup, with abcd-shaped defaults), and itd-39's scope-aware memory retrieval takes the memory payload + context brackets. Under consideration.

Skills and adversarial review

Matt Pocock's Claude Code skills repository is a primary reference for abcd's current skill-shaped surfaces — adversarial review at intent-stage, plan-to-issues conversion, design discovery, and disciplined debugging:

  • /grill-me (MIT) — relentless interview that stress-tests a plan or design until shared understanding is reached. The verb name grill in abcd's /abcd:intent grill sub-verb is borrowed from this skill; the productivity-skill structural template (SKILL.md shape: purpose / trigger / procedure) is the template abcd's grill skill follows.
  • /grill-with-docs (MIT) — grilling that updates CONTEXT.md / ADRs inline as decisions crystallise, rather than batching documentation. abcd's glossary-aware grill mode adopts the capture-while-grilling (inline-update) pattern verbatim: when grill sharpens a term, it writes to terminology/ immediately — never batched at session end. The three-clause ADR test (hard-to-reverse + surprising + real-trade-off → open ADR) is adapted from this skill's engineering template.
  • /to-prd (MIT) — turn the current conversation context into a PRD. abcd's grill Phase 2 (silent PRD synthesis) adapts Pocock's seven-section PRD template verbatim: Problem Statement / Solution / User Stories / Implementation Decisions / Testing Decisions / Out of Scope / Further Notes. Pocock's instruction — "do NOT interview the user in this phase — synthesise from what the grill just built" — is honoured in Phase 2's design: no further questions, silent synthesis only. The /to-prd skill's engineering structural template is the authoritative source for this shape. See Matt Pocock's skills philosophy at aihero.dev/skills.
  • /to-issues — break a plan, spec, or PRD into independently-grabbable issues using tracer-bullet vertical slices. Adjacent to /abcd:intent plan and /abcd:capture promote.
  • /triage — state-machine-driven issue triage with role-based moves. Conceptual precedent for /abcd:capture's open / resolved / wontfix folder-as-status convention.
  • /zoom-out — surface broader context or a higher-level perspective. Inspires the /abcd dispatcher's "where am I in this project right now" status surface.
  • /diagnose — disciplined reproduce → minimise → hypothesise → instrument → fix → regression-test loop. Methodological precedent for the audit-fix loops abcd runs across intent-fidelity-reviewer, lifeboat-oracle, and the cross-document-fidelity role.
  • /tdd — red-green-refactor loop with integration-test bias. Adjacent discipline to abcd's acceptance-gates: both insist on observable criteria before code.
  • /prototype — throwaway prototype branched between runnable terminal app (state/logic) and side-by-side UI variations. Pairs naturally with abcd's design-fiction intent format (v2) — both invite cheap exploration before commitment.
  • /improve-codebase-architecture — structured architecture review pass over an existing codebase.
  • /setup-matt-pocock-skills and /write-a-skill — install + authoring conventions for skills themselves; abcd's skills-versus-rules boundary (skills are procedural-workflow shaped; rules are declarative) is documented against this lineage.