01 / Practice / 2026

Chiang Ning is a Melbourne-based Registered Architect & Project Manager with 20+ years across education, civic, commercial, and residential work.

Disciplines03 / 03
01 / 03

Architecture

Education, civic, and commercial buildings, from masterplan through construction administration, with care for material, programme, and statutory complexity.

Explore
02 / 03

Project Management

End-to-end development management: feasibility, procurement, consultant coordination, cost discipline, and stakeholder reporting across the lifecycle.

Explore
03 / 03

AI Expertise

Practical, accountable use of AI inside an architecture and PM practice. Augmenting judgment without diluting authorship.

Explore

Get in touch.

Want to unlock AI in your organisation without compromising human accountability and creativity? Get in touch and I'll come back within the day.

The Nakagin Capsule Tower Was Designed to Change. So I Built One That Does.
27/8/2026·AI

The Nakagin Capsule Tower Was Designed to Change. So I Built One That Does.

Kurokawa's Nakagin Capsule Tower, Tokyo 1972: 140 prefabricated capsules bolted onto 2 concrete cores, every one of them designed to be unbolted and swapped out on a 25 year cycle. None ever were, and the building was demolished in 2022 having never once done the thing it was designed to do, which means the idea was built exactly once, at one height, in one packing arrangement, and then stood for 50 years as a single frozen sample of a system that was supposed to have variants. This is the tool that generates the variants, and the starting point was a file nothing on the machine could open. Nakagin+Capsule+Tower.skp is SketchUp's closed binary format with no converter available, no assimp, no Blender, no licence, so every normal route to a mesh was shut. What is true of a .skp and not widely known is that SketchUp writes PNGs into the file, the saved model view plus a thumbnail for every component, so scanning the bytes for the PNG magic number and cutting to the end marker recovers images out of a file you cannot otherwise read. That returned the saved model view and 3 capsule thumbnails, blank end, mirrored, and the one with the round window, which is all that was needed: the raked oxblood blade over each lift overrun, the white 2 storey podium with its recessed shopfront band, and the square-edged capsule. A static mesh could not have driven a parametric tool anyway, so what was wanted from that file was never geometry, it was intent, and everything else came from the published dimensions. The seed of the whole thing is 5 numbers: a capsule 2.3 by 3.8 by 2.1 m at about 8.7 m2, a round window 1.3 m across on the outboard end, 2 cores at 11 and 13 storeys, 140 capsules, 52.5 m. 8.7 m2 is the number worth sitting with, because that is the entire dwelling, sold to Tokyo salarymen as a second home for the working week. The part that separates a parametric model from a pattern of boxes is that capsules seat rather than float: each one bolts to whichever core face it lands on, so the distance out is solved by a ray from the core centre hitting the box that is the core rather than set as a fixed offset, which is what lets the whole ring twist 7 degrees a floor with every capsule staying seated instead of drifting into space or driving into the concrete. Then every candidate is tested by separating-axis against every other core and against every capsule already standing on that floor, and anything that would drive through a neighbour is dropped rather than drawn interpenetrating, which is why placement has to run floor by floor: a slot can only be tested against what is already standing at the same level. That produces the 2 readouts that are the actual point of the tool, slots filled and clashes dropped, against the usual capsules, cores, storeys, height and GFA. The original tower opens at 140 capsules, 73% filled, 44 dropped, and those 44 are not a bug, they are the staggered pair of cores getting in each other's way exactly as they do in the real building. It matters because raising the core count does not simply multiply the capsule count and pushing the cantilever out can send it down, so the counter tells you the moment a move has stopped adding accommodation and started making a shape. Any tool that only counts what it drew will tell you every scheme is a success; this one counts what it refused to draw. 4 presets ship, and they are 1 solver at 4 parameter sets rather than 4 models. Three towers puts the same capsule across a row of 3 cores at 5 m centres, staggered in height and tied at every 4th floor by a bridge, and returns 256 capsules at 78% filled on a footprint 3 slots wide. Taller version pushes the concept to 36 storeys and 118.8 m with banded packing putting a service floor every 4th level, 2 clear storeys at the base and cores widened to 6 m, and the answer it gives back is the interesting one: double the height of the original and you get 280 capsules rather than 140, at 56% filled with 88 dropped, so it scales and it scales badly, the service band eating a quarter of the floors while the fatter cores throw more capsules into each other. Spiral stack is 1 core, 3 faces, capsules rotating 7 degrees a floor with a 0.4 m slide and a varying cantilever, and comes back 100% filled with 0 dropped because a single core has nothing to clash with, which makes it the cleanest scheme by the numbers and the least buildable in every other respect, a useful reminder of what those counters are not measuring. The modulation group is where the modular idea gets stretched: packing rule as full, scatter with density and seed, checker, banded, stepped or spiral; how many faces of the core are used and how many capsules sit side by side on each; twist per floor; a triangle-wave slide with a period of 4 floors; cantilever and its variation up the tower; and the 2 joints, stacked and side by side, controlled separately. Scatter runs off a deterministic generator so seed 7 always rebuilds the same tower, because a random arrangement you cannot get back to is not a design option, it is an accident. The solver is 1 file of about 300 lines with no React in it, returning core positions, capsule transforms, link bridges and metrics, and the drawing is a separate problem, which is why capsules go into 4 instanced meshes, shell, glass, frame and bolted bracket, and a thousand-capsule scheme still turns at full speed in a browser tab. Save PNG takes the current view; Export GLB writes the building and only the building, with the ground grid and shadow catcher deliberately outside the exported group because their textures are generated in code and cannot be serialised into glTF. Limits are named plainly. It is a massing and quantity study, not a building: no structure, no capsule fixing, no lift calculation, no fire escape, no smoke shaft, no services, so it will report GFA and packing efficiency and will confidently draw a 36 storey version that does not have enough lifts. The capsule is an envelope rather than the real monocoque with its fitted interior. The clash test is in plan only, and nothing tests a capsule against the bridge running past it. And it is not the Nakagin: it opens on the Nakagin's numbers because that is an honest place to start, but the real building has an irregular arrangement no rule reproduces exactly, so 140 capsules at 73% filled is a faithful reading of the logic rather than a survey of the building. The close is about the input rather than the tower. The input was a file that could not be opened, in a format there is no software for, of a building that no longer exists, and the usual response to that is to give up or to spend a day modelling it by hand from photographs. Instead: read what the file would give up, take the published dimensions, write down the rules the building was built on, and generate every version the architect never got to test. Modelling gives you 1 building; writing the rules down gives you the whole family, and it takes about the same evening. Kurokawa's argument was that a building should be able to change. The building never did. The rules still can.

24 MCP for Architects+PM, At Your Fingertip.
26/8/2026·AI

24 MCP for Architects+PM, At Your Fingertip.

For 2 years the answer to whether AI could touch your model was no, not really: you could describe the model to it, paste a schedule at it, ask it to write something about the model, but the model itself sat in ArchiCAD or Revit untouched because the software had no way to let anything in. That changed quietly and most architects have not noticed. MCP stands for Model Context Protocol and the name is worth ignoring; what it actually is, is a small program that sits between Claude and a piece of software and lets Claude use that software the way you would. Not a file export, not a plug-in that does 1 fixed thing, but the running application with its real API, driven by description. ArchiCAD exposes 173 commands this way through the free Tapir add-on, Rhino will build and solve a Grasshopper graph, Microsoft Project hands back the critical path straight off the .mpp the contractor emailed you, and QGIS runs the site analysis. This page is 24 of them, grouped by where the work actually happens, with what each one does and the line that installs it. The model itself is 7: ArchiCAD, Revit through RevitCortex for 2023 to 2027, Rhino including Grasshopper, SketchUp, AutoCAD LT with AutoLISP executed from a prompt and an ezdxf fallback, Speckle as the pipe between all of them, and IFC read directly through IfcOpenShell for when a consultant will not send their native file. The programme is 2, and they are the ones people ask about most, because a construction programme is a database that happens to be drawn as bars: MS Project reads .mpp and MSPDI without opening Project and returns tasks, dependencies, critical path, float and baseline variance, and Primavera P6 does the same for .xer files without a P6 licence, which matters when you are the architect being handed a contractor programme rather than the one writing it. The site and the job record is 3: QGIS for layers, processing and print layouts, Autodesk Construction Cloud and BIM 360 through the Platform Services API for projects, folders, document versions and issues, and Chrome as your own logged-in browser for planning schemes, council portals and the data sheet behind a form. The documents is 8, which is where most of a project manager's week goes: Purple Hammer for construction PDF takeoff with read and write access to the worksheet cells and the ability to render a region of a drawing so the model can actually look at it, Excel for cost plans and schedules of values and drawing registers, Word producing real .docx with headings, tables and styles, PowerPoint producing real .pptx, Outlook and Teams through the Microsoft Graph API, SharePoint through the CLI for Microsoft 365 so Claude works on the job folder rather than on whatever you remembered to attach, and Notion through its own official server. The visual work is 4: OpenArt for image and video, Affinity, Canva, and DaVinci Resolve for the flythrough and the site progress cut, which reaches the free edition through an in-app bridge. Two things are said plainly rather than glossed. First, only 8 of the 24 run on this machine every day and the other 16 have not been personally tested, which is marked on every entry rather than implied away. Second, the Microsoft problem: every Office server on the list is written by somebody who is not Microsoft, because Microsoft's own official servers for Outlook, Word, Teams and SharePoint live in the Agent 365 catalogue for enterprise agents in Copilot Studio with no public install line, the one official server an individual can point a client at is read-only and scoped to Entra identity data rather than documents, and there is no official Microsoft Excel or PowerPoint server at all. The community ones work and install today, and they also want access to your mail and your practice drive, which is a real decision rather than a formality. The close is the part that transfers: for most of a career the software has been a place you go to do work by hand, the file being the thing and everything in it there because you put it there click by click, and an MCP turns the application into something you can talk to while it is open, so the file stops being a destination and becomes a live thing you can ask questions of. Which is why the first one to connect is the software you already open every morning, not the most impressive one on the list, because it is the one where you already know what a wrong answer looks like. None of these have judgement: ArchiCAD will happily swap every composite in the building including the ones that were right, and the API says it succeeded whether or not it did, so only reading the model back tells you the truth.

I Built a Facade Tool Into My Live ArchiCAD Model. Here Is What Broke.
24/8/2026·AI

I Built a Facade Tool Into My Live ArchiCAD Model. Here Is What Broke.

The gap being closed is small and very annoying: you have a facade screen in the model, you want to study 20 versions of it, so you either rebuild the curtain wall by hand 20 times or take it out to Rhino and then face the part nobody enjoys, getting it back into the model that issues the drawings. This time the round trip is skipped entirely. ArchiCAD has run a JSON API on localhost for years and the free Tapir add-on makes it usable, so Claude Code talks to the running application rather than to a file, while you are in it. The first call came back with the port, the project and the add-on version; selecting a curtain wall and asking what was selected returned facade 1, a curtain wall on Level 1, 4.55m tall, 383 frames, 126 panels, without a coordinate being typed. The design decision that mattered most was not geometric: the entire building is loaded as frozen context with raycasting switched off on every mesh, so it is scenery that cannot be clicked, hovered or moved, and exactly 1 element stays live. Nothing was guessed about that element either. It was read off the live model frame by frame: 123 battens, 40 by 100mm at 100mm centres, 12,502mm long and 4,550mm tall, all 126 panels deleted so it is a pure screen, plus head and sill rails and 2 end posts at 70 by 700mm. The tool opens on those exact numbers so every change is a deliberate departure from what is built rather than a fresh invention that happens to look similar, and the test that follows is the useful one: if it cannot reproduce what exists it has no business proposing what does not, so the as-built screen was rebuilt through the tool and every batten landed within 0.0002mm of where it already was. 4 systems then share 1 grid engine: vertical battens, undulating relief, woven ribbons, and standard terracotta tiles on a steel lattice. What unifies them is a field, a function over the face returning minus 1 to 1, in flavours of sweep, wave, diagonal, ripple, bulge, alternation and seeded noise, with each system feeding 2 fields into different properties, rotation and depth for battens, blended depth for relief, pivot angle for tiles. Containment is a constraint the solver cannot break rather than a warning that gets ignored, and it is subtler than it sounds because a batten rotated 60 degrees presents a much wider face than one sitting square, so the rotated footprint of the end elements has to be allowed for before deciding how many fit. Fixed spacing drops elements until the run fits, fill mode derives spacing so the run exactly fills the opening, and shifting sideways is clamped to the slack. Depth turned out to be the more architectural problem: the first relief version was flush at the outer face and grew inward, so a 620mm block was reaching into the slab, which is the wrong direction for a relief screen, so blocks now share a back plane and protrude outward with a set out from plane control and a readout that goes red when a design would reach the slab. The number used most is clear gap, the smallest distance between neighbours, which goes negative when they physically collide and caught one preset overlapping by 7mm. Writing back is 1 button and the output is columns and beams with a building material, grouped, on their own layer, 737 elements for a 680 tile screen in about 5 seconds, schedulable rather than a mesh, with a deliberately boring safety model: one layer of its own, rebuilds only delete elements found on that layer, and the original curtain wall is never deleted, only parked with its layer index recorded. The confession section is 4 bugs that all looked like success. 188 potted plants sat directly behind the facade blocking every interior view because ArchiCAD library objects export as IFC proxies with an empty name field and the real name lives on the IFC type through a separate relationship, and they were 70% of the model's geometry, so fixing the filter took the context from 10 MB and 596,000 triangles to 0.9 MB and 65,000. The old curtain wall was still in the frozen context because its rails, panels and end posts are not aggregated under its container and come out as loose proxies, leaving 8% of the context sitting exactly where the new facade builds. ArchiCAD refuses to modify or delete elements on a hidden layer and the delete command returns success anyway, reporting 737 deleted while deleting none, so the next build stacked a second copy and the count came back as exactly double. And the model went pale mid-session because HighlightElements dims everything not highlighted, while the cleanup call to clear it had been failing silently since the schema requires the colours array even when clearing with an empty element list. The pattern in all 4 is the same: the API said it succeeded, and only reading the model back told the truth. Limits are named plainly. It is bound to 1 element in 1 project with the element ID and anchor as constants, so pointing it elsewhere is real work rather than a setting. The woven system uses flat plates at alternating angles rather than genuinely twisted ones, which reads correctly at facade scale and round-trips as ordinary elements but is still a compromise. It is a geometry and quantity study, not a facade: no structure, fixings, movement, tolerance, fire or maintenance access, so it reports openness and linear metres of timber and says nothing about whether the thing stands up. And the API is where the time went, the parametric part being the easy afternoon. Closes on what transfers: this is territory that has belonged to Grasshopper for 15 years and most architects never entered it because the entry price was learning a visual programming language well enough to think in it and keeping the skill warm between projects. No Grasshopper was opened. What was needed was knowing what the facade should do, and being stubborn about checking whether it had actually done it. The skill is not prompting, it is verifying.

AI Playbook for Contract Admin: 16 Skills, One Month On Site.
24/8/2026·AI

AI Playbook for Contract Admin: 16 Skills, One Month On Site.

Contract administration is the part of practice nobody photographs. It is the Sunday before the report is due, spent reconciling a claim against a schedule of values nobody has opened since March, with a delay notice on top claiming 30 days the programme never lost. It is not one task, which is why one prompt never fixed it. It is a chain: the claim assessment needs the site record, the certificate needs the reconciliation, the report needs all of it. So the whole month is written down as 16 Claude Skills, in the order the month actually happens, and the free pack plus a 25 page guide is on the page with no email wall. A skill here is a small folder of written instructions Claude loads when the task calls for it, so step 9 already knows what step 4 decided. The organising idea is a line drawn through the month. On the left is the work only you can do because the contract names you to do it: whether a claimed percentage, a variation or a delay is actually owed, how many days an event cost practical completion, the signature on the certificate, and closing a defect at re-inspection rather than off a photo the builder sent. On the right is everything that gets you to that point, which is mechanical, evidence-bound and exactly what a model is built for: captioning a month of site photos by trade and area, putting claim, QS assessment and your own control figures on one line sorted by the size of the gap, testing every claimed day against the critical path with concurrent delay named rather than hidden, and assembling the report on the practice's own letterhead. The tool assesses, you certify, and that order never reverses. The 16 run in 6 groups. The month recorded, 2: site-log captions the camera roll with trade, area and what each image evidences and asks rather than guessing a location, site-minutes writes the meeting up with every action owned and dated and every carried item keeping its original number. The claim assessed, 4: claim-check tests every claimed percentage against the schedule of values and reports the delta rather than the total, separating work in place from materials on and off site, qs-reconcile puts 3 sets of figures on one row sorted by the largest difference and checks the QS assessment's own arithmetic independently, progress-certificate shows the arithmetic in full from contract sum through variations, retention and previously certified to the amount now due and stops if it disagrees with last month, cost-report puts budget, committed, spent and forecast on 1 page with a reason attached to every movement. Time and change, 4: variation-log ties each item to the clause it stands on and tests the notice against the contract time bar, separating genuine variations from rework and claims dressed as instructions, eot-check measures the claim against the approved programme because days that do not delay practical completion are not an extension, programme-update works from the approved programme rather than drawing a fresh one so slippage stays visible, risk-log sweeps RFIs, minutes and correspondence into one register ordered by what is blocking work. The records kept, 2: control-doc writes the month into the workbook the project is run from, reconciles the variation register against the variation folder both ways and leaves every formula and protected cell intact with a cell by cell change log, funder-report fills somebody else's locked return without touching their formulas or rounding the progress percentage up. The report written, 2: report-writer assembles the document from work already assessed with the executive summary written last, house-style applies one written definition of the practice's identity so 12 documents from 4 people still look like one office. Closing out, 2: defects-list numbers every item once and keeps that number for the life of the job, located by level and room, separated from incomplete work and damage by others, with one extract per trade, and write-a-skill bottles the run you just finished so next month starts as one command instead of 16. Every skill is printed with its full prompt and a copy button, what to give it, what you get back, how long it takes, what it replaces, and the one check that matters, which is usually the place where assessment could be mistaken for certification. The limits are named rather than buried: these skills assess and do not certify, they cannot measure the building, a variation is a contractual call and not a clerical one, most delay claims shrink at the critical path step and should be reviewed before they issue, control workbooks and funder templates belong to other people and get written into carefully, and contract documents are contested commercial data so which account they go into is a deliberate decision. Free, no gate, in the official Claude Skills format.

A Construction PM's Month, as 23 Files.
18/8/2026·AI

A Construction PM's Month, as 23 Files.

A construction PM's month reads like a departures board: everything queued, everything timed, half of it already delayed, and almost none of it the job you were hired to do. The claim lands on the 25th, the minutes are owed by Friday, the programme has to be marked up before the control group meets, and the report has to be assembled out of 6 other documents that do not agree with each other. None of it is hard. It is relentless, and it arrives in the same order every time. So the board is written down: 23 rows, one per job, and each row is a file. A skill is a page of plain text, no code, no install, no API key, that describes one job in the order you do it and is read by the model before it starts work. The alternative is what most people are doing, which is re-explaining themselves every time they open a chat, same context, same standards, same output format retyped from memory slightly differently forever. Two complete SKILL.md files are printed in full with copy buttons, claim-check and programme-update, both under 400 words, so the reader can see how little is in one. The 2 headings doing most of the work are Output format, which stops you renegotiating the shape of the document every month, and The one mistake to avoid, which is the thing you would say out loud to a graduate on their first claim and the sort of knowledge that otherwise walks out the door when someone resigns. The test for whether a job deserves a file is 3 questions: have you done it 5 times, do you do it roughly the same way each time, would you be annoyed if a graduate did it differently. All 23 are grouped by when you reach for them. Starting up, 6: brief-maker turns a recorded call into a brief the client can sign, grill-me interrogates that brief until nothing is vague, site-check makes the first pass over the planning controls, feasibility-qs tests whether the budget survives the brief, qs-estimator costs the scheme, timeline draws the programme. Every week, 4: meeting-minutes, site-log, programme-update and sync-control-doc. The money, 5: claim-check tests every claimed percentage against the schedule of values, variation-log ties each variation to its clause and notice date, eot-check separates claimed days from days that actually hit the critical path, cost-report puts budget, committed and forecast on 1 page, progress-certificate drafts the certificate for a named person to sign. Month end, 4: bga-monthly-report, report-writer, risk-log and handoff. Then the 4 document jobs, pdf, xlsx, docx and pptx, which are Anthropic's rather than mine, free to everyone, and responsible for more of the week than several of the ones written here. 18 of the 23 download as a free skill pack with no gate. The other 5 do not, and the reason is the most useful part of the page: they reach into branded templates, named cells on controlled spreadsheets, a house minute format and a folder structure that only exist in one office, so downloaded they would fail on line 1 or, worse, produce something confident and wrong. In their place is the blank 6 heading template and the build sequence: pick the job you most resent because resentment is a reliable signal of repetition, fill the template in badly in 20 minutes, run it on a real job rather than a test one because test jobs hide the gaps, fix the file rather than the output, and repeat about 3 times. The first mistake was writing them too clever, long files handling every variation, which made output worse by burying the method under edge cases. Limits are named plainly. These files draft, they do not assess and they do not decide, and the failure mode is not a crash but plausibility: leave a gap and the model fills it with something reasonable instead of stopping to ask, so you get a document that reads beautifully and prices a scope nobody agreed to. Every file therefore ends with the same instruction, list every assumption made and every figure that could not be verified, and that list is read before the document. A file makes you faster at your own method rather than giving you a better one, there is no memory between runs and no accountability for the outcome, and nothing here reads a contract it was not given. The hours shown against each row are the author's own, off real jobs, rounded, and the second number is a draft arriving rather than a job finishing. The board fills itself in; somebody registered still signs the bottom of it.

I Designed a Parametric Facade Without Grasshopper. Then Wired It Into ArchiCAD.
17/8/2026·AI

I Designed a Parametric Facade Without Grasshopper. Then Wired It Into ArchiCAD.

One evening, a photograph of the Al Bahar Towers, and a working parametric facade standing in a live ArchiCAD model as 650 native objects. The point is not the geometry, it is the gap that closed: getting a parametric idea out of a sandbox and into the model that actually issues the drawings. The build ran as a conversation and the module was wrong twice, which is shown rather than tidied away. The first attempt came back as one continuous folded surface, elegant and wrong, because the Al Bahar screen is not a surface but a few thousand discrete kinetic units standing about 2 m off a glass curtain wall, each with its own actuator. The second was a hexagon folding like an umbrella, closer and still wrong. What landed was a triangular cell carrying 3 four-point panels, corners fixed as frame nodes, centre node travelling out on the actuator while the edge midpoints draw in, which is what opens the slots and lets the glass show. Then a bug caught by eye rather than by number: the rows were not staggered, so the elevation read as continuous horizontal slots instead of six-pointed rosettes, and the cause was exact, successive rows not offset by half a cell so one row's apexes landed between the next row's bases and the structural nodes never met. One line, and afterwards every interior node is shared by exactly 6 units with 0 failures. The division of labour is the lesson: the architect supplies judgement, the machine supplies verification. What worked, described honestly: a device with a single driving parameter, openness 0 to 1, because a real mashrabiya has one actuator so the BIM object should have one handle; a tool that says no, reporting mean shading, distinct actuator positions and how far each panel goes out of plane, and flagging when a 650 mm travel warps panels past a quarter of the cell; a library part that builds itself, because ArchiCAD ships a converter inside its own app bundle that turns library part XML into a .gsm, so no New Object dialog, no pasting 4 scripts, no typing 11 parameters and getting one subtly wrong; and iteration that costs about a second for 264 panels, because the entire pattern lives in per-instance parameters. What did not work is 5 things, 4 of them the API rather than the design: a 30 minute hang on a call that was not even needed, a part that embedded and then could not be found because its ancestry was empty, an embed path that works exactly once and is refused ever after, a boolean that had to be a real boolean rather than 0 or 1, and the one worth learning from, a facade that reported 130 placed, 130 driven, zero failures and was wrong, every unit silently using the library default travel of 450 mm instead of the design's 650 mm. No errors is not verification. Reading the value back out of the model and comparing it to what you asked for is verification. The transferable structure is one parametric object placed many times with per-instance numbers rather than a mesh pushed into the model, which keeps it light and schedulable, and the second app makes the point harder: a precast cell whose outer and inner triangles give a deep splayed frame, a faceted pyramid or a flat panel depending on 2 numbers, so a whole elevation is the same casting at different settings, with the mould count tracked live because 306 cells and 15 moulds is the difference between built and value-managed out. The closing observation is about access. All of this is Grasshopper territory, and most architects never enter it because the entry price is learning a visual programming language well enough to think in it and then keeping that skill warm. No Grasshopper was opened. The skill that mattered was knowing what the facade should do, not knowing how to wire a definition together, and the labour of manual drafting was simply not in the loop. Limits are named plainly: you still have to know what good looks like, it will build the wrong thing confidently, the API is where the time goes, and it is a geometry and quantity study rather than a facade, with no structure, fixings, movement, tolerance or fire.

I Wrote Down How I Do My Job. Here Are All 24 Files.
16/8/2026·AI

I Wrote Down How I Do My Job. Here Are All 24 Files.

6 months of building the same small object over and over: a plain text file that describes one job I do, in the order I do it. There are 24 now, and this page has all of them, with 2 printed in full so you can see how little is actually in one. A skill is not intelligence and it is not technical. It is a text file with instructions, no code, no install, no API key, written the way you would brief a graduate in their first week, and the model reads it before it starts work. The rest is consequences of that. Most people using AI at work are re-explaining themselves every time they open a chat, same context, same standards, same output format retyped from memory slightly differently forever, and a skill is refusing to do that a sixth time. The test for whether a job deserves one is 3 questions: have you done it 5 times, do you do it roughly the same way each time, would you be annoyed if a graduate did it differently. All 24 are grouped by when you reach for them rather than by job title. Before you draw, 6 of them: grill-me interrogates a brief until nothing is vague, client-brief turns a messy first meeting into something signable, fee-proposal turns agreed scope into a staged fee, qs-estimator costs the scheme, new-project sets the job up, deep-research digs across sources and names them. While you draw, 10: zoning-analyser reads the planning controls with a clause cited per figure, code-checker does the first pass, spec-writer turns a cut sheet into a clause, precedent-hunt finds built precedents rather than mood images, mj-prompter writes render prompts that hold architectural fidelity, gpt-image-2 edits the render, exterior-hero-shots plans the shot set first, blender-mcp sets the scene, archicad-mcp reaches into the live model, awards-submission drafts the entry. Once it is on site, 4: rfi, meeting-minutes, progress-certificate, tender-compare. Then the 4 document jobs, pdf, docx, pptx and xlsx, which are Anthropic's rather than mine and already free to everyone, listed anyway because they do more of the week than several I wrote. Two complete SKILL.md files are reproduced in full with copy buttons, grill-me and rfi, both under 250 words, sharing the same 6 headings, which is the template rather than a coincidence. A blank template is given to copy and fill, along with the 10 minute build and the ordered steps that follow it: pick the job you most resent because resentment is a reliable signal of repetition, fill the template in badly, run it on a real job rather than a test one because test jobs hide the gaps, fix the file where it got it wrong, and repeat that about 3 times. The confession section is the useful part. The first version of every one of these was wrong, not broken which would have been easy to spot, but plausible: you leave a gap and the model fills it with something reasonable instead of stopping to ask, so you get a fee proposal that reads beautifully and prices a scope nobody agreed to, or a programme quietly assuming a soil classification you never supplied. The fix is a single instruction now baked into the template, list every assumption made and every figure that could not be verified. The second mistake was writing them too clever, long files handling every variation, which made output worse by burying the method under edge cases. Limits are named plainly: a skill makes you faster at your own method and does not give you a better one, so sloppy method now produces sloppy work at speed and volume; there is no memory between runs and no accountability for the outcome, the 2 things a graduate has that this does not; blender-mcp and archicad-mcp need a live connection to the software and do nothing as text alone; and the commercial motive is disclosed, workshops, with the files working fine without them. Closes on the part that transfers: you already have a method, it lives in your head and walks out of the practice when someone resigns, and writing it down is worth doing even if you never point a model at it, because 3 of these processes turned out to make no sense once they had to be typed in order.

Transition From AI Slop to Engagement
16/8/2026·AI

Transition From AI Slop to Engagement

Agentic AI is spectacular at the middle of a project, and the middle of a project is the part that stopped paying. Draw a job left to right, feasibility through handover, and ask where the value sits, and you get 1 of 2 shapes. Which one you get has nothing to do with how much AI you use: 5% or 95%, the shape is set by 2 questions, who owns the brief and who signs the work. Up the side is perceived value, which is not hours or effort or difficulty but what the client assigns with their attention, their money and their trust, and they assign it partly by comparing you to everyone else who could have done the same stage. That is the whole argument, because value follows scarcity, not difficulty, and AI just made a hard stage easy for every practice at once. The middle stage, documentation and delivery, is where AI genuinely shines: monthly reports, minutes, RFI drafts, spec sections, schedules, EOI responses, first-pass fee proposals, work that used to eat a Friday now running while you are on site, and best held as skills rather than prompts you rewrite every time. It sits at the bottom of the curve anyway, because the practice down the road can now do it identically, with the same models and the same weekend of setup. It did not lose its purpose, it lost its pricing power, and those are different things: an hour of your judgement at the front now directs 100 hours of production instead of 10. The left end is brief and concept design, where every model trained on the same material hands 100 architects the same scheme, and where the useful move is not generation but interrogation, writing the brief yourself and then having the model attack it for what is vague, unevidenced or assumed. The right end is relationships and repeat work, the end most charts leave off and the one a practice actually lives on: nobody appoints an architect because of an email sequence, and somebody registered still signs the drawings, carries the insurance and stands in front of the client when it goes wrong. A dashed loop runs from that right end back to the brief, because what site and handover teach you sharpens the next one, and an all-AI pipeline has no loop since nobody was in the room to hear it. AI slop, drawn as the top chart, rarely arrives as a decision, it arrives as 3 conveniences in a busy month: a concept generated because the fee was thin, a documentation set produced faster than anyone can check, outreach written by a model and sent to people who can tell. Includes 3 real copy-paste prompts, one that turns a repeated monthly task into a reusable skill, one that interrogates your own brief instead of writing it, and one that prepares you for a client meeting without scripting you, plus the transition in 3 moves: automate the middle deliberately, spend the recovered hours at the 2 ends rather than on more middle, and keep the signature obvious. Names its limits plainly: a human at both ends of a bad project is still a bad project, the curve is not a fee schedule, and on genuinely commodity work automating the whole chain is rational and the curve flattens. The smile curve is Stan Shih's, 1992; the content version that prompted this is Tianyu Xu's.