Agentic instruments for the design studio — supplying the logics, language, and data behind a design judgment, and leaving the judgment to the student.
103 instruments live · 11 benches · built with Claude Code
I teach architecture, and I’ve been building the tools I wanted my students to have. Good Tools is the result: a set of studio instruments, made with Claude Code, that do the legwork behind a design decision, such as pulling the site data, finding the precedents and running the numbers, and then stop. The decision belongs to the student. I believe this is where computation in architecture is going: small tools that show their work, built by the people who use them. The project I’m proudest of is RAP, the Radical Accessibility Project, built with and for blind and low-vision students.
The same eleven words run down the left menu and through this page — Site through Studio, with Misc holding the one thing that isn’t an architecture instrument. Each word opens its bench of tools, listed best-developed first. The menu shows the core tools by default; its bottom switch opens the rest.
Read the ground and its climate — terrain, earthwork, weather files, the figure-ground.
Precedent and research — context for any image you find, catalogued into a growing project library.
Living systems over time — succession, planting, a drawing that grows, a century of change.
Gardener · Village · Swale · Palimpsest · +2 more
Make and shape geometry — describe it, form-find it, test it against the forces.
Eco-Architect · Conjure · Proving Ground · Ensemble · +3 more
Structure and assembly — form-finding, trusses, stairs, screens, the wall section.
Represent and make — projection, camera, light, the print shop, laser and print prep.
Fabricator · Portraitist · Pegboard · Figurant · +23 more
Prove it — program, daylight, sound, wind, comfort, carbon, sightlines, framing.
Diagram Studio · Acoustician · Sounding · Caustic · +15 more
Words about the work — the charter you start from, a defensible thesis, adoptable critics.
Brief · Critic · Editor · Interlocutor · +1 more
Skills tutoring, the trail map and code snippets.
Coach · Toolsmith · Skills Map · Primer · +4 more
The whole process, the class record and its infrastructure — the archive wall, QR drops, your own trace.
In one of the studios using this? ARCH 273 and ARCH 371 each have a page that walks the semester and prunes the menu to that studio’s tools.
Every instrument at once: the catalog, grouped by the same words · how to use them, step by step · how each compares with the professional software · Ask Prof which one fits · the glossary · about & disclaimer
The headline instruments in process order — brief, site, form, drawing, proof, critique, learning — each with what it does and a note on where it runs. Open any one of them from its title; fuller context is in the statement below, and what “runs as” actually means is unpacked in Inside the toolkit.
Before there is any geometry there is a claim about what the project is for. Brief walks a student through authoring that charter — program, ambitions, and goals stated as things that can actually be tested — and hands the goals to Eco-Architect and Proving Ground in their own format, so the charter travels with the design instead of being retyped. When a scheme drifts, the charter is what you check it against.
Runs as — entirely in your browser; no account and no AI call.
Turns a real parcel into citable evidence — sun path, prevailing wind, climate, zoning and code, hydrology, history — so a student’s site claims are sourced, not asserted. Hard data is free and cited; AI judgment is tagged for the student to verify. The measured ground, exported clean to Rhino before anything gets designed on it.
Runs as — a web app; the open climate, terrain and zoning data and the Rhino exports need no account, the AI claim pass does.
A drawing that grows. A real stand — individual trees competing for light, dying, seeding in — inks its own crowns through a mark grammar the student authors, so the simulation and the drawing never drift apart. Three versions switch in one page: grow it, let its lineages evolve, then make it honest — an ensemble of futures drawn as an uncertainty band, per-stem kill odds, and cited trait ranges. A stylized teaching model of succession, and explicit about being one.
Runs as — a client-side simulation in the browser; public, no API cost.
Every site is a palimpsest of what it used to be, and “normal” is usually just the year you first saw it. Scrub the real federal record — 100-foot (30 m) cells, 1985 to today — backward and watch the pixels flip class on your own ground. Switch on predict mode and it asks you to commit a reconstruction first; the distance between that guess and the record is the shifting baseline, measured.
Runs as — in your browser, scrubbing the federal land-cover record; no sign-in.
A planting grown on ground you actually measured, painted by the site’s own water. The Surveyor’s terrain comes across, flow routing finds where water collects and where it leaves, and the plot sorts itself into habitat bands — then a stand plays out over decades on that painting. Nobody places a plant: willows end up in the swale and bur oak on the dry shoulder because that is what the ground allows. Drawn as a hatched plan or as the model wearing the same marks. Landform hydrology, stated as such — not a drainage study.
Runs as — entirely in your browser, the growth in a Web Worker; no account.
The studio’s shared memory for references. A student drops in an image they found and gets it identified and contextualized — architect, project, the moves worth borrowing, related plans and photographs — and it accrues into a searchable class library of images and texts, tagged and cross-linked. No picture yet? Name a subject and it researches a brief — themes, precedents with the drawing to look for, vocabulary and readings — where a link survives only if the run actually opened that page, and everything else is marked from memory — verify. It began as a local app over the filesystem (Obsidian-compatible) and now runs in the toolkit, so the archive is shared and every identification stays inspectable rather than locked in someone’s chat history.
Runs as — a web app in this toolkit (sign-in); grew out of a local, Obsidian-compatible filesystem app.
A pin-up wall with memory — the studio’s shared wall and its class record in one. ARCH 273 and ARCH 371 each run their process archive here on an assignment board: one row per student, one column per class day, comments in every cell. A day’s column closes to students when the next class starts, so the record is what was on the wall that day; each module’s deliverable column stays open all term, so a reworked final can go back up. Every upload carries a title, an author and a timestamp automatically, a PDF posts page by page with the original kept whole, and the metadata underneath shows who’s engaging and who’s gone quiet. Any row, column or post plays as a slideshow or comes down as a zip. A reference grid under every wall holds the instructor’s library, the class’s and a pool every classmate can add to, and a whole pin-up day comes back as one PDF for the swell-paper printer. Half of every ARCH 273 module grade is this record.
Runs as — a web app with a backend (Supabase) and accounts.
The vibecoded answer to Grasshopper, two roads on one page. Describe a form in plain language and Claude writes the parametric program that builds it — then read the exact code it wrote, drive the sliders it chose, edit it and re-run. Or key Rhino-style commands (box 20 30 12, array column1 5 x 6) that execute instantly with no model call at all. One engine under both roads, exporting native .3dm.
Runs as — Claude behind a server proxy on the describe road, pure browser on the command road; sign-in required.
Push massing and watch the physical consequences move: rotate the building and solar gain shifts; raise it and wind exposure and views change. Encode design intent as testable rules, then round-trip the same constraints to Rhino 8 / Grasshopper. It makes the link between form and forces legible while a scheme is still soft.
Runs as — a zero-build web app; exports native Rhino 8 + Grasshopper python.
One eco-lounge is a building; a dozen is a settlement, and that is a different problem. Place small gable lounges on a Superfund site’s measured terrain — bedded, grounded, lifted or perched — lap their plinths into one walkable network with code-real stairs, and draw the remediation cap from the EPA record so the ground tells you where to touch it lightly. Then let the walker negotiate every lounge’s proportions and placement at once against mutual winter shading, borrowed summer shade, the cap and the links. It finds a negotiated arrangement, not the optimum; the studio map is where a whole cohort reads each other’s ground.
Runs as — entirely in your browser; the scoring and the walker in Web Workers. Publishing to the studio map needs an account.
Conjure and Eco-Architect fused. Bring any massing — the demo jig, something you authored, or a Rhino .3dm you drag in — and test it against sun, wind, ventilation, views, water, daylight and earth, live. State the goals as rules and an in-page optimizer pushes the form toward them, showing the trade-off front rather than one “best” answer. As the studio brief puts it: you set the composition, the site gets a vote, you keep the taste and the judgement. Seven versions sit behind one door, on the five studio sites or any coordinate you paste in: V6 breaks every force open across the whole year and draws the air itself — around the building and through the room — V7 is ARCH 273’s bench, with a student manual for importing a Rhino model and reading its verdicts, and V4 sets a live solver walking every variable of that same bench. A study saves and shares as one project file or link, and the viewport exports as plates, a layered package for Illustrator, or a film.
Runs as — entirely in your browser; the optimizer in a Web Worker, .3dm read and written by WebAssembly.
The Radical Accessibility Project: making architectural production work without sight. It drives Rhino from the command line, generates tactile drawings (PIAF swell paper) and 3D-printed reliefs, reads plan and section aloud as spatial audio, and writes structured alt-text. Its browser pages carry the parts a studio reaches for directly — Studio turns a typed building into a plan you hear, print and open in Rhino; Tactile Drawings cuts plans, sections and section-pair reliefs from a Rhino model; Pegboard prints a Braille-ruled jig for wire models; Sound Relief prints a recording as a landscape a hand can read; Texture Compiler measures a wall’s surface from phone photos under a moving lamp; Print checks a model and puts it on the 3D printer’s card with a spoken report. Built local-first and open-source so anyone can replicate it, and developed with a blind co-researcher, its primary user. The constraints it surfaces sharpen spatial description for every student, not only blind ones.
Runs as — its twelve toolkit pages in your browser (Alt Text and Quick Describe make an AI call and need sign-in; Print hands the slicing to Bambu Studio through a small helper on a Windows computer); the Rhino controller local + CLI, open-source · repository
Frame a massing the way an American crew would. Boolean a few boxes and cylinders into a volume and Stick fills it with plates, studs, joists and headers — storeys falling out of the lumber rather than a round number, so changing to a 9-foot wall really does change how many floors fit. You get the cut list, the places that need a beam, and a machine-checked promise that nothing floats.
Runs as — entirely in your browser; exports OBJ, a cut list as CSV, and SVG.
One building carried from proportion to price. V1 puts every dimension of a gable barn on a slider with an honest material readout; V2 runs the whole project on Proving Ground V7’s bench — a structural pre-check of every framing member against published loads and lumber tables, with the undersized ones drawn in rust; a glazed greenhouse end, simulated hour by hour through the winter for the heat it needs; the drawing set; a takeoff priced line by line; bid packages issued as frozen revisions; and the quotes that come back leveled against the estimate and each other. The Foreman edits the barn in plain language, but nothing changes until you have seen the before and after and applied it.
Runs as — entirely in your browser, except the Foreman, the one AI call (sign-in); exports a PDF + DXF drawing set, an .xlsx estimate and bid packages.
Build a wall, roof or floor the way it is actually made — layer by layer, exterior finish to interior — and let the drawing carry the numbers. The hatched section redraws live over aligned temperature and vapor-pressure charts; a dew-point pass names the plane where winter condensation would land; and the effective R counts the studs bridging the insulation, so it always comes in under the number printed on the batt.
Runs as — entirely in your browser; exports a true-size SVG section.
Hear the room before it exists. Reverberation, room modes and flutter echo computed from the dimensions and materials you set — or from a Rhino room you import — with up to eight speakers and a microphone placed in it, and the mix rendered for both ears on a mixing board, your own sound files included. You listen to the fix instead of reading that a number moved, and the whole project saves and shares as one file or link. Two siblings go further into curved rooms: Sounding builds one from the ground up and walks a listener through it; Caustic reads one against theory, with a wave tank and a choir you mix by keyboard, voice or screen reader.
Runs as — the room simulation in your browser; the optional read-back is one AI call. Sign-in required.
Move a window and watch the whole year answer. Windows on any wall, each with its own shading slab, plus skylights — and a climate-based simulation on real weather-file data that re-runs on every move, reporting daylight the way the standard defines it rather than as a pretty gradient. Proving Ground pipes a massing straight in.
Runs as — the annual simulation in a Web Worker in your browser; the optional read-back is one AI call. Sign-in required.
Schemes A, B and C in three columns and one honest table. Every cell links back to the tool that produced the number and prints that metric’s blind spot; a metric you never measured stays missing rather than quietly scoring zero; and it ships with no default weights at all. You set the weights, which means the ranking is yours to defend.
Runs as — in your browser; it reads your own trace for numbers the other tools already produced.
The first hour of every feasibility study, made teachable. Pick a parcel and a teaching zoning district and watch the legal bulk envelope get carved one rule at a time, so you can see which rule removed which volume. Then fill it — floor-to-floor, plate shape, a core you place yourself — and find out what actually fits before anyone draws a plan.
Runs as — entirely in your browser; exports OBJ and CSV.
The plans examiner’s first read, as a calculator that cites the law rather than a chatbot about it. List the spaces on a story and it works out the occupant load, the exits it needs, travel distance, stair and door widths, plumbing fixtures; give it a lot and a district and it reads the zoning envelope and which rule actually binds. Every number is a rule record with its clause and an honest verification status. The model never produces a number — it explains the sheet, cites a rule or abstains. Not a legal determination.
Runs as — the sheet entirely in your browser, no account; the explaining desk is one AI call, sign-in required.
Read a cut, then draw one. A massing floats in an orthographic viewport with a cut plane you slide through it, and the exact analytic section draws itself on the plane as it moves. Freehand your own poché over it and the engine scores it against the truth with the misses named — “you filled the open courtyard” — rather than a percentage.
Runs as — geometry in your browser; the optional narration is one AI call. Sign-in required.
One model, three ways of drawing it: a perspective camera with a real lens, a parallel axonometric you can orbit, or a true oblique with cabinet and cavalier presets and an adjustable depth ratio. Drop in a GLB, STL, OBJ, PLY or Rhino .3dm and pick a display mode off Inker’s shelf — ligne claire through to black poché.
Runs as — Three.js on your own GPU, entirely in the browser; the model never leaves your machine.
One big sheet — 36″ × 36″ by default — made of several rigorous perspectives instead of one. Each view is a real construction with its own station point, picture surface and scale, drawn from your model by a hidden-line engine: flat, or unrolled off a cylinder or a sphere for a panorama up to a full turn, framed as a rectangle, an arch or an ellipse and collaged over the views beneath. The construction stays on the sheet — horizon, vanishing points, the 60° cone — beside a plan that draws every station at scale.
Runs as — entirely in your browser; exports one true-size layered SVG and a RhinoPython script of named views.
Design the way your viewport draws, then take it home. Ink and pixel lineweights, silhouettes versus creases, isocurves, flat against modeled shading, shadow-map resolution and the artifacts it causes, the paper behind it all — with every control naming the exact .ini key it writes, so the mode you tuned here installs in Rhino as a real display mode rather than a screenshot you try to match.
Runs as — entirely in your browser; exports a real Rhino .ini display mode.
One model in, three fabrication strategies out. Load a parametric form or your own STL / OBJ / PLY / .3dm once, then switch strategy: interlocking waffle ribs, stacked contour layers — both exporting cut sheets that print true to size — or print prep, with bed fit, least-support orientation, overhang flags and time and material estimates honest enough to argue with.
Runs as — entirely in your browser; exports true-size SVG cut sheets and STL.
The site-model generator. Cut a chunk of the Surveyor’s measured ground and make it physical: a 27-inch base at 1″ = 100′ covers 2,700 feet of real terrain, split into tiles sized to your own printer’s bed. The mapped roads, water and building footprints come with it, cut into the ground so the model reads as somewhere. One chunk, four fabrications — printed tiles, a waffle grid, stacked contours or fold-scored paper strips — and the same ground full size as a Rhino .3dm to keep designing on. A key map lets you drag the chunk into place against real latitude and longitude, and a shared datum keeps five section models lined up in a row honest about which ground sits higher.
Runs as — in your browser, off the Surveyor’s measured ground; exports STL, DXF and .3dm.
Board and page layout — the stand-in for the InDesign workflow while you wait on a license, or when you just want something faster. Sheet sizes in ARCH, ANSI and ISO, multiple artboards, margins, snapping and a grid; export one board as a PNG or every board as a single PDF that prints true to size.
Runs as — entirely in your browser; exports PNG at your chosen DPI and a multi-page PDF.
A review partner, explicitly not a verdict. It adopts a critical persona — tectonic, social, formal — to give the lay of the land and surface blind spots, and it helps build the case for review: pulling a project down to a defensible thesis, sequencing the drawings that prove it, and interviewing the student for the questions a jury will ask. One synthetic position among many — weigh it against human critics, never substitute it for them.
Runs as — LLM behind a proxy; each persona is a system prompt.
A tutor that gives the real answer and teaches the why behind it. A student asks how to do something — loft a surface in Rhino, set up a spread in InDesign, clip a mask in Illustrator — and gets the actual move, paced to their level, with the one thing most likely to break named in advance, so they can re-derive it next week instead of pasting it once. The tool picker sets its vocabulary, not its limits: a Rhino question that turns into an InDesign question still gets a full answer.
Runs as — Claude behind a server proxy, streamed; sign-in required.
A trail map of 2D and 3D skills from beginner to advanced. Each step opens a tutorial video and the shared concept notes, with “builds on / leads to” links and a hand-off to Coach when a student gets stuck. It charts what to learn and in what order; Coach is the tutor for the learning itself.
Runs as — a static map + video library; no sign-in.
The capstone of the authoring ladder — the statement’s promise made concrete. A student describes the parametric instrument they wish existed and Claude writes its program on fenced rails; the student then drives the sliders it chose, reads the annotated code, edits and re-runs it, and keeps the instrument in a personal library. Its Forge goes further: fork one of the toolkit’s own tools — 22 of them, the Librarian, Surveyor and Proving Ground editions among them — and steer the copy in plain language, every change kept as a revision you can restore. Authoring a small tool is the fastest way to learn what a tool is — and where to stop trusting one.
Runs as — Claude behind a server proxy; programs and forks run in a sealed sandbox with no network. Sign-in required.
How an architecture office and its projects are actually paid for, as three linked ledgers. The office: roster, salaries, overhead and the multiplier that sets every billing rate. The project: a fee budgeted into hours per phase under each compensation basis — then add an overrun and watch who pays under each. The cash: the same job month by month, so the line of credit a profitable lump-sum project still needs is a number, not a warning.
Runs as — entirely in your browser; no account.
The map of 3D geometry itself: nine domains from projection through curves, surfaces, solids and discretization, each skill tiered and carrying a precise definition, why it matters in studio, the Rhino vocabulary that operates on it, and a demo you can push. Skills Map charts what to learn; Primer says what the thing actually is.
Runs as — a static page with live in-page demos; no sign-in.
An atlas of vernacular building, after Lloyd Kahn’s Shelter: thirty-three traditions from the iglu to the tulou, each drawn in section to scale beside a 6-foot figure, and the fifteen passive techniques they are made of, each with its physics and its math set out term by term. Two benches put it to work — what a wall of any material and thickness does to a day’s heat, and which traditions were built against the same forces as your site’s weather year.
Runs as — entirely in your browser; no account.
These 34 are the headline instruments. The other 69 live in the catalog, filed under the same eleven words.
Students are forming the ability to discern and find the sophistication needed to justify their designs in an era where we design not just with more compassion but in an environment saturated with data. Whether they draw on an increased understanding of site-specific environmental forces, conduct more thorough historical precedent analysis, or bring more voices, both human and nonhuman, to drive creative form generation, students are striving to give language to their work. As design studio teachers, we strive to level up their reasoning, synthesis, and analysis of both a given real-world site, the people who inhabit or inhabited it, and the invented buildings and systems to be placed on it.
AI tools — specifically agentically coded tools — can give them the logics, language, and data to make more sophisticated judgments, and can let them take on computational analysis in ways that were out of reach until this year. Design thinking remains a curious iterative system built around the asking of questions, the gathering of information and expertise, and then the forming of that data into built and unbuilt forms or systems of whatever variety. This way of thinking perfectly aligns with the pedagogy of teaching people to relate to this new way of computing; the loop of proposing, testing, and revising is the same one you run whenever you direct one of these tools. LLMs are just this: the new generation of computers, and the studio is a natural place to learn them.
I will both demonstrate to the students in class how to vibe-code the more sophisticated tools I’ve built (which I’ll give them access to) and, together with them, vibe-code simpler tools and algorithms for their own design formation and decision-making that they can use directly in their studio projects. I foresee these becoming as ubiquitous as the proprietary software our students already engage with in school and in the profession. I believe they should learn to move quickly and embrace these tools; to iterate often in a “trust but verify” stance that pushes them to find edge cases and failure modes; and to engage in creative brainstorming with these tools in a fluid but skeptical manner. I intend to introduce these during class studio sequences, and I will probably also run a series of agentic-coding-for-design workshops, as it will likely take a few sessions to get students — and colleagues — up to speed. (To colleagues graduating from chatbots to Claude Code or Codex who want more control over the inputs, outputs, memory, and behavior of their models, I’m glad to help, and I’d point you first to the concept of an agent harness.)
The main outcome and learning objectives are the same as in any design studio: to make sure students level up their explanation of both the final architectural design and the process of arriving at it. Teaching students to work with AI follows many of the same basic tenets as teaching them to become resilient designers, which is why building these tools should reinforce the core of the studio rather than compete with it. The tools are a set of studio instruments, detailed in the examples above — a Brief to write the charter before any geometry exists, a Surveyor for site analysis and an Eco-Architect and Proving Ground for designing against real forces, a Coach to tutor production with a Skills Map and a Primer to chart the terrain, a precedent Librarian, a studio Archivist, a Critic for critique and portfolio, a Daylighter, Acoustician, Stack and Scoreboard to hold the claims to account, and a bench of drawing and fabrication tooling running from Sectionist and Inker through Fabricator and Relief. Primary among them, and the throughline of my research, is the Radical Accessibility Project, which makes architectural production work without sight and is where I practice the verify half of “trust but verify” at the highest stakes. All of these are in some stage of production, fully built with Claude Code.
How do we reinforce design thinking while teaching AI literacy? Specifically: how do we teach students to iterate, to hunt for edge cases, and to judge when to productively offload cognition to a tool versus when to double down on the old-school, analog repetition that actually builds the neurons?
For the student who wants to know exactly what happens when they click. No programming needed to read this, and nothing here is a metaphor — every claim is something you can check yourself, in this tab, in about a minute.
toolkit.allmeans.works is a name registered at a registrar (Porkbun), and its DNS record points at Vercel — a hosting company whose machines sit in data centres around the world. The nearest one answers, which is why the site is quick from a studio in Champaign and quick from a train..3dm is a binary format with a real geometry library behind it (rhino3dm), compiled to WebAssembly — near-machine-speed code the browser runs in the same sandbox as everything else. It is how a web page reads and writes Rhino’s own file without Rhino, and without an upload.When you drop an OBJ, a photograph or a weather file onto a tool marked In your browser, the page reads it with the browser’s own File API — straight off your disk into this tab’s memory. There is no upload step being skipped; there is no code in the page that could upload it. Close the tab and it is gone.
The tools that do keep something — Archivist, the Dossier, your Toolsmith library and forks — say so on the page, and what they keep is listed in About. You can verify all of this yourself: open the browser’s Network panel and drop a file in. A tool that runs in your browser makes no request at all.
An AI call. When a tool asks Claude something, your browser does not talk to Anthropic — it posts to a small function on this site’s own server, which holds the API key, checks you are signed in, meters what you have already spent, calls the model, and streams the answer back. That indirection exists because anything shipped to a browser is public: press F12 on any page here and you can read every line of its code. A key sitting in that code would be found and spent by a stranger within days. It is also the reason those particular tools ask you to sign in and the rest do not.
Each student account gets 25 AI runs in a rolling 24 hours — or $2.00 of model time in the same window, whichever runs out first, because a one-line answer and a six-image critique are not the same run. Every run is written to your own trace with what it actually cost in tokens, visible only to you in the Dossier. If you hit the wall, the far larger half of the toolkit — everything that computes in your browser — keeps working as if nothing happened.
Four services, none of them exotic, and the whole thing is small enough that one person pays for it.
| Piece | What it is | What it costs |
|---|---|---|
| GitHub | The repository — every file, and every change ever made to every file, since the first commit. It is also where the automated checks run. | Free |
| Vercel | The host. It builds the site from the repository, serves the result from a global CDN, and runs the small server functions the AI tools post to. | Paid — the AI functions need to run up to five minutes, which the free tier won’t allow. |
| Supabase | The database (Postgres) behind accounts, works, pin-ups and the run log. Every table has row-level security on: the rule about who may read a row is enforced by the database itself, not by our code remembering to ask. | Free tier, so far |
| Anthropic | The model behind every AI call — and behind the writing of the tools themselves. | Metered per token; the daily limits above are what keep it bounded. |
The domain name itself is registered at Porkbun for about the price of a coffee a year. That is the entire infrastructure.
None of this was typed out by hand. It was built by directing Claude Code in plain language: the agent reads the repository, writes code, runs it, reads its own errors, and fixes them, in a loop, while a human stays the author and editor. What keeps that from producing a pile of inconsistent pages is that the rules live in the repository as plain text — a CLAUDE.md of house rules and a DESIGN-RULES.md of typography, colour, lineweight and control behaviour, which the agent reads at the start of every session. That is an agent harness: memory, permissions and standing instructions written down so behaviour is predictable instead of improvised. It is why every tool here has the same slider, the same black ink, and a dark mode that actually works.
The honest test of everything above is that you can check it, so here is how.
F12, or ⌥⌘I on a Mac. Elements is the page’s live structure, and editing it changes what you see immediately (it changes nothing for anyone else). Console is where the tool talks. Network lists every request the page makes — open a browser-side tool, push it hard, and watch that list stay empty.src/lib/toolkit-nav.ts — one entry per instrument, carrying its name, its bench, whether it needs an account, and its steps. The left menu, the catalog, the manual and this page all read from it, which is why their names and their benches cannot drift apart.Right now you use these tools. The direction of travel is that you edit them, keep versions of them, and hand them to each other — because the fastest way to learn where a tool should not be trusted is to have opened it up.
Most of that already exists, in Toolsmith. Describe an instrument you wish existed, watch Claude write its program on fenced rails, read the annotated code, change it, re-run it, and keep it in a personal library that exports as a single .instrument.json file you can hand to a classmate. Or open its Forge, fork one of the toolkit’s own tools, and steer your copy in plain language — the way these tools were built — with a what changed diff after every edit and a question you can ask of any line you select.
Filled square is built and usable now, outline is planned:
Two constraints on all of that are fixed and are not up for negotiation. A student-authored tool runs on fenced rails — a fork in a sealed frame with no network of its own, no access to the page around it, and no access to anyone else’s data, its code re-checked every time it is saved and every time it is served (the one edition that talks to Claude asks the Forge, which meters the call like any other) — so authoring adds no new way for the site to be attacked. And forking never touches the original: your version is yours, and the shared one stays exactly where it was for everyone still using it.
The honest note on timing: this gets built as the studio needs it, not to a schedule, and the list above is ordered by intent rather than by date. If there is a tool here you want to bend into something else, saying so is the fastest way to move it up the list — jsclark2@illinois.edu.
ARCH 273 · Revival Architecture — Fundamentals of Design I, UIUC, Fall 2026. Regenerative interventions on five Superfund sites, read across two hundred years. The syllabus names four of these instruments as its keystones and calls them instruments, not oracles. The whole document is below; every page opens.
Students in the studio should start at the ARCH 273 class page, which walks the semester week by week and prunes the menu to the tools each module calls for.
For colleagues thinking about doing the same — the general case, not this particular site. (For how this one works, hosts and ships, see Inside the toolkit above.) None of this requires being a programmer; it requires being willing to direct one.
These tools weren’t typed out by hand. They were built with Claude Code — an agentic coding tool you direct in plain language from the command line. The difference from a chatbot is control: instead of copying snippets out of a chat window, the agent reads your files, writes code, runs it, sees the errors, and fixes them, in a loop. You stay the author and editor; the agent does the typing. That is what vibe-coding means in practice, and it is why a studio teacher can ship working tools without a CS degree.
The single most important thing to understand is that these aren’t one app. They fall into a few buckets, and the bucket — not the idea — decides how, and whether, you host it.
| Kind of tool | Where it runs | Why |
|---|---|---|
| Static web | Any static host — Vercel, Netlify, GitHub Pages (free) | No saved data, no secrets; it just runs in the browser. |
| LLM-backed | A web page plus a tiny serverless function | The API key can’t live in browser code — the function holds it, proxies the calls, and caps spend. |
| Local app | A small Node / Python server on your own machine | The filesystem is the source of truth (Obsidian-compatible); nothing to host at all. |
| Web app + backend | A frontend host plus Supabase (Postgres, auth, storage) | Needs accounts and saved data — e.g. hundreds of students posting weekly. |
| Rhino-coupled | Distributed as a script, run inside Rhino / Grasshopper | It drives desktop software; an MCP server bridges the agent to Rhino. |
The “runs as” line under each tool above tells you which bucket it is in.
Any tool that calls an AI model has a key, and that key is money. It can never sit in code running in a student’s browser — someone will find it and run up the bill in a weekend. The fix is a thin server function between the student and the model that holds the key, limits the rate, and sets a hard spend cap. The same layer is where FERPA lives: the moment a tool stores student work or sends it to an outside model, you owe students an honest account of where it goes. There’s also an equity edge — a shared campus key is fair but costs the department; asking students to bring their own is cheaper but regressive.
The build method is the same stance I want students to learn: get something running, then deliberately try to break it — the weird input, the empty case, the edge it wasn’t designed for. The agent is fast and confident and often wrong, so its output is a first draft to be checked, never a final answer. Once you outgrow the chat box, the next concept is the agent harness: the scaffolding — memory, the tools it’s allowed to call, the rules it must follow — you wrap around a model to make its behavior predictable instead of improvised.
The practice behind the toolkit, some honest thoughts about AI in a studio, and where your work lives.
All Means Works is an umbrella design + research practice and platform by John Clark, an architecture educator at the UIUC School of Architecture. The 26 Summer AI Workshop is one initiative under it. The Design Toolkit — this site — is its set of studio instruments: tools for reading a site, keeping a reference library, growing a landscape, shaping and testing form, drawing, fabricating, and talking about the work. Each instrument supplies the logics, language, and data behind a judgment while leaving the judgment to the student.
The menus group every instrument by what it does — the eleven words, Site through Studio and Misc — or browse all tools on one page, grouped the same way and filterable by tag.
Some tools here compute real methods — solar geometry, span tables, climate files, pin-jointed forces. Others ask an AI to reason or write. Both kinds simplify the world to teach you something about it, and both can be wrong: a model is a smaller, more legible version of reality, never reality itself. Each tool tries to say out loud what it doesn’t know — read those notes, they are part of the lesson.
Nothing on this site is engineering, code compliance, or construction documentation. These are teaching instruments. Before anything is built, priced, or relied on, verify it with a licensed professional.
AI is a confident collaborator, and confidence is not correctness. The position this toolkit takes: the AI proposes, you decide. The tools are built with Claude Code in a “trust but verify” stance that values iteration and edge-case hunting over fluent-sounding answers. Every tool shows its answer; the few that can also grade your guess first — paint the daylight, draw the cut, predict the shadow — keep that drill behind an opt-in predict mode, there to sharpen your judgment, not to replace it. The most valuable thing you make here is not a rendering or a number; it is your own reasoning, on the record.
So use these instruments the way you’d use any instrument: with your eyes open, against your own intuition, and alongside humans — your critics, your classmates, your own hands. When a tool and your gut disagree, that disagreement is the most interesting thing in the room. Chase it.
Most tools run entirely in your browser — nothing you load leaves your machine. The ones that spend an AI call ask you to sign in first, and each signed-in run is logged to your own trace, visible only to you, so your process is something you can look back on and print for review.
Questions, corrections, or a tool you wish existed? jsclark2@illinois.edu
The words the tools and their how-to steps use, defined once. Every instrument carries its own steps under How to use in its header; the whole set is collected in the manual, which also explains the parts that work the same way in every tool.
The furniture. These mean the same thing on every page, so they are worth learning once.
?predict=1. Off by default: tools show their answers.The file types the steps name. Anything marked as running in your browser reads these locally — nothing is uploaded.
The numbers the tools report back, in the order you tend to meet them. Readouts are imperial; where a figure came from an SI source the metric value follows in parentheses.
A word here that a tool uses differently, or one missing that you had to look up? That’s a bug in the writing — tell me and it gets fixed.
The tools above run in this toolkit and their own repos. Use the left menu — the same eleven words — to open them.