Build the team with Gigawatt
How does my approved design become a working team, and how do I know each new agent really works?
- Source
- Internal's lesson, src/sara-week3/internal/lessons/anw-w3-l07.md (Internal b518c35b, 2026-10-22 17:15), read by md_week3.py.
- Copy
- Current Markdown is vendored byte for byte from the Internal commit in Source by vendor_week3.py. Historical publication records: 10-06 Exercise 1 with Sara's yes; 10-07 Exercise 2 and the Module 2 send-route and follow-up fixes, student 58c60d50; 10-08 Exercise 3 and the l05/l11 diagram fixes, student 55061386. Those records do not qualify later Outlook changes. Module 3 and 4 drawings are rendered from the Mermaid in the lesson file (md_week3.py --figures).
- Prompts
- Word for word from the lesson file Internal ships (course/workforce/week3/). Not run end to end from Learn.
- Checked in the app
- Not checked in the app from Learn.
- Open to students
- Yes.
- Other view
- one scroll (one part at a time is the lesson; one scroll is kept to compare)
Staff review only: full controlling prompt. Students paste only the short request below.
Use the native aibl-the-professor agent to guide the Week 3 lesson "Build the team with Gigawatt". Read course/workforce/week3/lessons/anw-w3-l07.md completely and the native aibl-course-guide and aibl-lesson-map methods for this app. You may read course/workforce/week3/reference/anw-w3-l07-details.md when they ask about a detail. You teach and read; you never build, stage, approve, install, prove an agent or run a job for them. The person you guide talks to the Operator (Gigawatt) in its own build thread. Do not call, spawn or route to any agent. Do not edit any file. Never write, suggest or pass on a yes; every yes is their own words in Gigawatt's thread.
Use these words exactly. The PRD is the design file Archie wrote, runs/<job>/design/prd-v<n>.md. Building mode is Gigawatt running the Fisk Method's eight phases out loud: Prime, Align, Research, Generate, Evaluate, Iterate, Document, Deploy. The phase block is the four lines at the top of each building turn. The thin slice is one real job run through the new lead and specialist on test case 1 before the rest is built; predicting its result and comparing is an observational eval with TOAST (say what you expect, observe, analyze, change one thing, test again). A rehearsal is a staged agent tried on test cases 1 and 5 with the slice's inputs and stand-in tool results; it is practice, not proof. An independent check is a clean-slate check of the staged files; it is a second-model review only when its model family differs from the builders'. Installing is copying the staged agents into the folders their apps use, on their yes in their own words (Gigawatt carries the install number), or on the pre-authorization they gave at the design yes when every check and every rehearsed case passed. Drift is a newer design version written after their yes: wording is a note in the install report; a change to what the team may do (a tool, a write path, sending or posting, a borrowed agent, a case) needs a fresh yes naming the change. Between the design yes and the install, agents stop only for the smoke alarm: money, sending outside, deleting, posting publicly, account authority. An agent's kind is new, reused or borrowed; a borrowed agent comes from another department and keeps its home there. The record is the one file that says which agents make up the team; the Charter Steward proposes it and the Chief of Staff files it with the install receipt, with no yes of its own. Name agents job title first, nickname in brackets on first use.
Ask open questions only. Never answer Gigawatt's questions for them, and never choose for them. Never promise more than the page does, and never read out test status. Never ask them to type a version or an install number.
Part 2. If asked, help them find what the design left open, read only, in sections 5 and 7 of the approved prd-v<n>.md under runs/<job>/design/. Tool names are read off the app's connector page word for word; never supply or guess one.
Part 3. If asked, read runs/<job>/build-log.md and the files under runs/<job>/rehearsal/slice/, read only, and help them put Gigawatt's tradeoff in their own words. They choose.
Part 4. If asked, read runs/<job>/setup/checker-v<n>.md and the reports under runs/<job>/rehearsal/, read only, and help them find each verdict, whether case 5 refused, and the "could not verify" lines. Say plainly that a rehearsal is not proof.
Otherwise, if asked, explain the step and what they should see.
Staff only: status, sources, what is not tested. Not student-facing.
Status: DRAFT, Sara-standard pass, 5 October 2026 (evening), on the Exercise 2 rewrite built against gigawatt/aw-week3-release-20261005. Status lives only here. Student text states each supported path as a plain rule, with no probe ids and no "built to" or "not tested" wording. Every student step and safety action from the rewrite is kept: the pointer line, "Yes, stage version 1.", the named PRD yes, "Yes, install 1.", allowing the app prompt, and the proof in a new thread. Mechanics moved to course/workforce/week3/reference/anw-w3-l07-details.md (source overrides/course/week3/reference/anw-w3-l07-details.md), linked where each detail is first needed.
Sources: Gigawatt's building mode and Deploy step (aibl-gigawatt, "Building mode", "Coordinating other agents"); aibl-agent-setup Steps 3 to 7 and "Rehearse before proposing an install"; aibl-fisk-method (the "stage version 1" question); design_approval.py (record-install refuses a yes without install <n>); Archie's pointer line; aibl-team-flow (stops with no team record); INTERFACES sections 3, 5, 6, 8; MODULE3-LESSON-NOTES-DRAFT, Lesson 3.
Plain rules on the page, still PENDING PROBE:
| Student text now (plain rule) | Probe | Where |
|---|---|---|
| Session shape, phase block, "approved prd-v2, unchanged" | P1, P2 | Part 1 |
| The deploy recheck: "If anything changed since your yes, it copies nothing" | P1, P2 | Part 5; details |
| Builders side by side in Codex; Codex may run them one after another | P4 | details |
Rehearsal briefs and reports under rehearsal/ | P5 | Part 4; details |
| The Archie round trip, a new PRD version, and the refused old approval | P6 | Part 3; details |
| "Read it, then allow it" for the app's prompt during install | Tyler's desktop sitting | Part 5 |
Resume from build-log.md in a new thread | no probe row | Start or resume; details |
If a probe fails, change the plain rule to what the probe showed; do not add test-status wording to student text.
Fisk loop lane, 8 October: Tyler's ruling adds each new agent's research, three-lens scorecard, version 1.1 and deployment notes to the build; Part 4 says what the student sees and where. No new yes.
Sequencing note: Gigawatt's Deploy ends with "one ordinary end-to-end job" through the Chief, but aibl-team-flow runs a team only from its record, which the Steward writes in the next lesson (l08). The page tells the student to expect that stop.
Sara-standard changes: paste prompt and controlling prompt name the lesson title, not a lesson number (the Professor routes by the map's id; the prompt names files by path); "owner" and "seat" removed from student text; PRD, kind and the record explained where first used; the slice and rehearsals named as observational evals with TOAST; every "say this" step names its thread.
Last lesson you said yes to your PRD, the design file the Architect (Archie) wrote for your team, and Archie recorded which version. Today the Operator (Gigawatt) builds it, with you in the room.
You give Gigawatt one line that points at your design. It asks what the design left open, builds your new agents, and shows you one real result partway through. You make one choice. A checker marks the work. Then the second door: you say yes to the install, in your own words, or, if you pre-authorized it last lesson and every check and case passed, Gigawatt installs and tells you. Then you prove each new agent works.
Each agent on your team has a kind. New means built for this team. Reused means one you already had in this department. Borrowed means it comes from another department and keeps its home there. Only the new ones are built today.
your new agents built, checked, installed and proven, with every step saved as a file in your job folder.
An agent is built when it does its job, not when its files exist. Seeing one real result mid-build lets you steer while changes are cheap.
You answer the open questions, make the mid-build choice, and give the one yes that installs (or gave it last lesson, as the pre-authorization). Nothing lands in your apps' folders without one of those.
Before you start
- Your pointer line. Archie recorded your yes and gave you one line for Gigawatt. It names your job folder, for example
runs/2026-10-06-team-newsletter/design/. If you lost it, find your folder underruns/and write the line yourself; it is only a pointer. - Your tools, connected. Any tool your design needs must be connected in your app. In Claude Code: Settings, then Connectors. In Codex: the Plugins page. You connect it yourself. If one is missing, Gigawatt tells you where to connect it, and waits.
- In Codex, your first message to Gigawatt starts "Ask the Operator (Gigawatt) to". Start every message after that in the same thread, your answers and yeses included, with "Tell the Operator (Gigawatt) this, word for word, and show me its reply word for word:", so each one arrives exactly as you typed it.
- Three threads. One with the Course Companion (The Professor), one with Gigawatt for the build, and a new one at the end for the proof.
Start or resume this lesson
Thread: a new one with The Professor. Open your prepared workbench, start a new thread, call The Professor by its role name, aibl-the-professor, and paste only this.
Use the native aibl-the-professor agent to start the Week 3 lesson "Build the team with Gigawatt". Read course/workforce/week3/prompts/anw-w3-l07.txt and course/workforce/week3/lessons/anw-w3-l07.md. Ask me one question at a time and wait. I will talk to Gigawatt in its own thread.
The full instructions your agent follows for this lesson are in course/workforce/week3/prompts/anw-w3-l07.txt.
Coming back to a build you stopped? Open a new thread with Gigawatt and paste your pointer line again. It checks your approval, then picks up where the build stopped. More: coming back to a build.
You paste your pointer line. You get Gigawatt's word that your approved version is unchanged, and a short status block at the top of every turn.
Gigawatt does the work in the boxes.The diamonds wait for you.
Do this now: give Gigawatt the pointer
Thread: a new one with Gigawatt. In Claude Code, start a new thread, type @ and pick aibl-gigawatt, then say this, with your own folder name:
Build the team from my approved design in runs/<job>/design/
In Codex, start a new thread and say:
Ask the Operator (Gigawatt) to build the team from my approved design in runs/<job>/design/
What you should see
Gigawatt says it is in building mode: it works through the Fisk Method's eight phases out loud (what each phase does). It checks your approval and names the version it found: "approved prd-v2, unchanged" (with your number). You never see a code.
Then, at the top of every building turn, four lines. This is the phase block:
the newsletter example (made up for this course)
PHASE 2 of 8 (Align)
CHECKPOINT: not yet: two tool names to check
ARTIFACTS: runs/2026-10-06-team-newsletter/build-log.md
OPEN DECISIONS: which sources the Trend Picker may read
Read the last line first. OPEN DECISIONS lists only what you must decide. If it says "none", Gigawatt is working and needs nothing from you yet.
Gigawatt asks you a few questions, one at a time: sources, tools and edge cases the design left open. You answer in your own words. You get a three-line brief to check before anything is built.
Gigawatt does not reopen the design you approved. If a question would change it, Gigawatt asks a fresh copy of Archie, in a file. You never carry messages between threads. More: questions that would change the design.
Tool names are copied, never guessed. If Gigawatt asks you for a tool's name, read it off your app's connector page, word for word. Today you only choose tools; they are granted at install. More: tool names.
Do this now: answer, then read the brief back
Thread: the same one with Gigawatt. Answer each question in your own words. Gigawatt saves them in build-log.md.
When the questions are done, Gigawatt restates the brief in three lines and goes on to stage version 1. Your design yes covers that: staging installs nothing. If the three lines do not match what you approved, say what is wrong, in the same thread, and Gigawatt stops to fix it first.
Right after that, before Gigawatt shows you any result, write one line on paper: what you expect your specialist to produce for case 1. You compare it in the next part.
Gigawatt builds your new agents in a staging folder, runs/<job>/setup/, where nothing is live. Then it runs one real job through your new lead and specialist: your test case 1, the ordinary job. This is the thin slice. You predict the result, read it, and make one choice.
This is your first observational eval, with TOAST: say what you expect, observe, analyze the gap, change one thing, test again. Your choice is the one change. More: how the builders work and the thin slice.
Gigawatt stops and shows you one real result and one tradeoff:
the newsletter example (made up for this course)
Result: the Trend Picker picked the new state rule on client deposits, with two sources.
Tradeoff: it found a second change that also matters. Covering one keeps the issue short.
Covering both makes it longer, and the Newsletter Lead has to cut elsewhere.
Which do you want: one change per issue, or up to two?
Do this now: predict, read, then choose
- Get out the line you wrote in Part 2. Don't change it now.
- Read the result Gigawatt shows you. It is also saved in
runs/<job>/build-log.md, beside the slice files underruns/<job>/rehearsal/slice/. Compare it with your line. That gap is the most useful thing you see today. - Thread: the same one with Gigawatt. Answer the tradeoff in your own words, with your reason. If you are unsure, ask The Professor, in its thread, to help you put the tradeoff in plain words. It will not choose for you.
If the build finds a gap in the design
Sometimes the build shows the design missed something real. Gigawatt asks a fresh copy of Archie, and you see one of three things: "The design still holds", and the build goes on; a new version that only changes wording so the design works, which Gigawatt notes as drift and goes on; or a new version that changes what the team may do (a tool, a write path, sending or posting, a borrowed agent, a test case), with a short changelog at the top. Only the last one stops: Gigawatt reads you what changed and waits. More: when the build finds a gap.
Thread: the same one with Gigawatt. If Gigawatt stops with a new version and you agree with the change, say this:
Yes, that change is fine.
Gigawatt records your yes against the new version; you never type its number. If you don't agree, say what is wrong, and it goes back to Archie.
A checker that never saw the build marks your new agents. Each new agent is also rehearsed on two of your test cases. You read three things and know whether the team is ready to install.
- The checker starts with a clean slate and writes findings first, then a verdict, to
runs/<job>/setup/checker-v<n>.md. Its label says how independent it was: an independent check used the same model family as the builders, a second-model review a different one. - The rehearsals try each new agent on case 1, the ordinary job, and case 5, the one the team must refuse. They are observational evals too: each report sets what the case should do beside what the agent did, and ends in PASS, CONCERNS or FAIL.
A rehearsal is practice, not proof. It runs your staged agent in a stand-in, before install. Real proof comes in Part 6. More: the checker and rehearsals.
Each new agent also gets a scorecard. Three reviewers that never saw the build score its instructions. Gigawatt rewrites them as version 1.1, they score again, and only a higher score keeps it. In runs/<job>/setup/<agent>/: the scorecard under eval/, what changed and why in instructions-changelog.md, how to use the agent in DEPLOY-NOTES.md. The score informs; the checker decides.
Do this now: read three things
Thread: the same one with Gigawatt. Open the checker file and the rehearsal reports under runs/<job>/rehearsal/, or ask Gigawatt to show you. Find:
- The checker's verdict, and its "could not verify" lines. Read up to five.
- Case 5 for each new agent: did it refuse, and say why? A team that does the job it should refuse is not ready.
- Anything marked FAIL that Gigawatt has not repaired. If there is one, Gigawatt brings it to you as one decision before the install.
Gigawatt shows you a short list of everything it will install. You check it and say yes, in your own words. You get your new agents installed, with the tools you chose, and your team on the record.
If you pre-authorized the install last lesson, Gigawatt does not ask. It checks three things first: every new agent's files pass the render check, no blocking finding is open, and every rehearsed case passed. All three held: it installs and tells you, with those lines quoted. One failed: it names which, and waits for your yes as below.
the newsletter example (made up for this course; your list will differ)
Install 1 writes:
- Newsletter Lead and Trend Picker: their agent files for both apps, profiles and skills
- one line for each in your roster, and the registry, regenerated
- the tool grants you chose in Align, and the model choices
- a copy of each agent for Claude Code's @ list
- the team's record, filed with this install
Say yes to install 1.
Check that your new agents are there and nothing else is, and that the tools match what you chose. A review skill for the Quality Reviewer (Kansa) may be listed too; that is expected.
Do this now: say yes
Thread: the same one with Gigawatt. Say it in your own words:
Yes, install it.
Gigawatt carries the install number and ties your yes to exactly the files on that list. A hesitation ("not yet") is not a yes, and nothing is installed.
Your app asks once more. Writing into your agent folders makes Claude Code or Codex ask you to allow it. Read it, then allow it: it is the mechanical gate for the yes you just gave, one click.
What you should see
Gigawatt checks the files once more. If a staged file changed since your yes, it copies nothing and names the file; say yes again to the new list it offers. If the design drifted in wording only, it says so and goes on. Then it installs and runs two record checks:
| The line | What it means |
|---|---|
Drift: 0 findings | Your rules and your agents' files agree. |
Seat records: ... 0 mismatch(es) | Every agent's tools match everywhere they are written. |
Then the Charter Steward proposes your team's record, the one file that says which agents make up the team, and your Chief of Staff files it with this install, your yes as its owner_yes. Gigawatt quotes the team check's OK line. You read the record next lesson; no yes is needed for it. More: the install in full. If Gigawatt tells you to close your app and open it again, do that before Part 6, so your agents load their new tools.
Each new agent does one small piece of its job, in a new thread. You get each answer, and whether it matched the shape its design file asked for.
A new thread matters: your app reads its list of agents when a thread starts, so the install thread cannot reach them. "Who are you?" is not proof. Proof is the agent doing its job. More: proving each agent.
Do this now: run each "prove I work" check
In Claude Code. Thread: a new one with Gigawatt. Start a new thread, type @ and pick aibl-gigawatt, and say:
Prove each new agent on my team in this new thread: run its prove I work case from runs/<job>/design/, and record what came back in 04-install.md.
In Codex. Thread: a new one for each new agent. Say this, with its job title and role:
Ask the <Role> to run its prove I work case from runs/<job>/design/agent-<role>.md.
Then, in Codex, start one more new thread and say:
Ask the Chief of Staff to run the ordinary job for this team.
What you should see
Each new agent's answer, in the shape its design file names. In Claude Code, Gigawatt records the input, the answer and whether it matched in 04-install.md.
Last, one ordinary job goes to your Chief of Staff: Gigawatt tries it in Claude Code, and you ask in Codex. Your Chief sends work to a team only from the record, filed with your install. Next lesson you read it and check each agent's tools. Your test cases run live, as observational evals, after that.
If you get stuck
| What you notice | What to do |
|---|---|
| Gigawatt stops at Prime | The approval is missing, an approved file was edited, or a newer version changed what the team may do. Gigawatt names which. Say yes to the current version in Archie's thread, then paste the pointer line to Gigawatt again. |
| Gigawatt asks for tool names you can't find | Open your app's connector page and read them off, word for word. If the tool isn't there, connect it first. |
| You said "yes" and nothing installed | Your words read as a maybe ("not yet", "hold on"), or a check failed first. Gigawatt says which. If you mean yes, say "Yes, install it." in Gigawatt's thread. |
| Gigawatt installed without asking you | You pre-authorized it last lesson, and every check and case passed; Gigawatt quotes the lines. If you didn't, stop and tell Gigawatt in its own thread. |
| Gigawatt says the install was refused after your yes | A staged file changed after your yes. Gigawatt names the file. Say yes again to the new list it offers. |
| Your app's prompt was closed or refused | Say "Continue the install" in Gigawatt's thread, and allow it this time. If it is refused again, close and reopen the app, then say it again. |
| A new agent is missing when you type @ in Claude Code | Ask Gigawatt, in Claude Code: "Why does @<agent> not show up in my @ list?" |
| The Chief says the team is not on the record | The record is filed with the install. Ask Gigawatt, in its thread, for the install receipt and the team check line. |
What you'll keep
Your new agents, installed and proven in your own app, and your team on the record. In your job folder: the build log with your answers and your mid-build choice, each new agent's scorecard and deployment notes, the checker's findings, the rehearsal reports, the install list you said yes to, and the install receipt, with any drift noted.
Before you finish
Check what is on your screen:
You can also say why a rehearsal is not proof, what drift is, and which five things stop your agents between your two yeses. Self-assessed. No gate.
Words you now own
- PRD: the design file Archie wrote; each change makes a new version.
- Kind: new, reused or borrowed: where an agent on your team comes from.
- Building mode: Gigawatt running the Fisk Method's eight phases out loud, from Prime to Deploy.
- Phase block: the four lines at the top of every building turn.
- Thin slice: one real job run through the new lead and specialist before the rest is built.
- Rehearsal: a staged agent tried on cases 1 and 5 in a stand-in, before install. Practice, not proof.
- Independent check: a clean-slate check of the staged files by a checker that never saw the build.
- Install number: the number Gigawatt gives the install list; your yes, in your own words, is tied to it.
- Pre-authorization: the line you may have said at the design yes. The install goes ahead on it only when every check and case passed.
- Drift: a newer design version since your yes. Wording is a note; a change to what the team may do stops for a fresh yes.
- Prove I work: one input and the answer shape that shows an installed agent does its job.
- The record: the one file that says which agents make up your team, filed with the install.
Next: read your team's record, and give each agent the tools it needs.