# The program
A build-along education program for people who want the capability, not just the concept. The teaching device is wayfinding in reverse: each session opens at the most mind-stretching end of a real research lineage (nanobot swarms, autonomous spacecraft, missions that outlive their designers) and works backwards to a small artifact the learner finishes on their own laptop that same session. Every artifact demonstrates one idea at a different scale: encode intent as a declaration, keep it revisable, and let a system carry it.
The far-future opener is honest, not decorative. Swarm robotics, generation-ship governance studies, and long-duration mission autonomy are live research programs, and each one is, at its core, an intent-representation problem. Our abilities and aims no longer fit in a two-line preferences field or a one-page brand vision. The stack that holds the bigger version of your intent exists now, and by the end of the program you will have built four small pieces of it yourself.
Audience: curious practitioners, creators, NGO and municipal staff, and working analysts. No prerequisite beyond willingness to run things in a terminal with an AI pair. Sessions are designed for live cohort delivery (workshop or livestream) and self-paced completion.
Module 1. Mission Directives for a Thousand Boids
Opens at: drone swarms, Kilobots (a thousand robots self-assembling from one shape declaration, Science, 2014), and the murmuration problem: how do you specify behavior for agents you will never individually steer?
Builds: Craig Reynolds' 1987 boids in about 100 lines of p5.js: separation, alignment, cohesion, and a flock with no leader and no flock-level plan. Then the central step: lift every hardcoded steering weight out of the code into a YAML mission-directive block the sim parses at load. The same agent code now flies patrol, converge-on-beacon, or quarantine-intruder missions depending on which directive file it carries. Learners add a machine-checkable success condition ("90% of agents inside the containment ring for 10 consecutive seconds") and an auditor loop that stamps PASS or FAIL on screen.
Stretch: hand your AI agent the directive schema and have it write a novel mission file, then run it unedited. First taste of an agent carrying your declared intent.
The lesson at this scale: the flock is never in the bird. Mission behavior lives in a declaration each agent carries, not in instructions a controller issues.
Module 2. Declare It Once: a Standing Query in Apache Flink
Opens at: NASA's Remote Agent (1999), the first AI to fly a spacecraft closed-loop, whose formally verified planner worked and whose deadlock arrived in the sibling subsystem outside the verified model. Watching system state on a human's behalf is an old, hard, valuable problem.
Builds: a one-node Apache Flink cluster and the SQL client, no Java. Learners create a synthetic price stream with the built-in DataGen connector, watch a continuous aggregate update live (their first query that outlives its execution), then write the real artifact: a MATCH_RECOGNIZE standing query that detects a dip-and-rebound pattern within a declared time budget. The engine watches the unbounded stream on their behalf, forever, without being re-asked.
The lesson at this scale: there are two kinds of questions, the ones you ask and the ones you post. A standing query is declared intent compiled into an observable machine state, and it ships in production BI stacks today.
Module 3. Frontmatter Is a Contract
Opens at: the boundary-loss failure, demonstrated live: paste a note whose publication conditions live only in prose into a toy intake script and watch every condition get silently discarded.
Builds: in a fresh Obsidian vault, learners move the conditions into YAML frontmatter (status, audience, platforms, a publish-after date, an owner), build a Bases kanban view driven entirely by those fields, then make the contract executable: a 40-line gate script that reads the frontmatter and refuses to publish any note whose declarations aren't satisfied, with a named-field error. Flip one field in Obsidian and watch the gate's verdict change.
The lesson at this scale: metadata that is executed stays true; metadata that is merely descriptive rots. The document can carry its own contract, and something has to run on it.
Module 4. Declare Your Terms (for NGOs, municipalities, and coalitions)
Opens at: commons that have survived for centuries, and the two rules that made them work: everyone knows who's in and what the boundaries are, and watchers plus graduated consequences are funded as real jobs, never assumed.
Builds: participants arrive with one live collaboration whose written agreement has drifted from practice (a grant consortium, a data-sharing MOU, a mutual-aid network). They audit it against four of Ostrom's design principles, rewrite it as a plain-language participation charter, then translate the charter into structured frontmatter: participants, boundary rule, contributions, prices accepted, scope of warrants, a three-step sanction ladder, and a named monitor. An AI agent then adjudicates three mock partner requests against the charter (one clean, one needing conditions, one out of scope) and cites the exact field that decided each verdict.
The lesson at this scale: a declared condition nobody is compelled to read is dead metadata. The gate only matters because something reads it.
Capstone
Each learner writes one real locked-gate declaration on one real document of their own: scope, gates at the right levels, an enumerated warrant list, and a review heartbeat. The four modules were the same artifact at four scales; the capstone is the learner's own.
Delivery notes
- Each module stands alone as a workshop or livestream episode; the set of four is a cohort arc. - Module 1 and 3 run entirely offline; Module 2 needs a laptop that can run a JVM; Module 4 needs participants to bring a live agreement. - Publish order matches series order: the flagship post introduces the argument, modules ship one per week behind it.