Here's what I fixed.

The little Home row that kept sneaking back onto your Inbox board is gone for good. A customer told us he deleted it three times and it came back every time, with nobody touching a thing — and he was right to be annoyed. The rule for when that row should show had changed weeks earlier, but the part of the app that draws the Inbox board, and the to-do board right alongside it, never got the update, so they kept quietly putting back a row that wasn’t supposed to be there anymore. Both are fixed now, and the row stays gone when you take it away.

You can tell Forge to stop asking permission for every step — once you trust it. Forge stops and checks with you before it reaches outside your folder or runs code it wrote itself. That’s the right default, and it stays the default. But once you’ve watched it work and you trust it, stopping for every step gets in the way — so there’s now a setting that turns the check-ins off and lets a long job run start to finish. It’s deliberately not a casual switch: turning it off walks you through exactly what changes, asks whether your work is backed up first, and takes a real confirmation — and a badge in the title bar always shows which mode you’re in, so you’re never guessing. One line it never crosses, on or off: the small handful of things that could actually wreck your computer are refused outright, not merely un-asked.

The free buttons work on the live dashboards now, not just the plain lists. Yesterday’s 1.0 gave every machine zero-gas buttons — check a box, push a date, move an item — but the release gate caught them promising to work on the visual dashboards before they actually did, so 1.0 shipped with them limited to the plain views and I said so out loud. Today they work where you’d expect them: right on the dashboard itself. The click reads instantly, the change sticks, and it still costs no gas — the app does it, not the AI.

The dashboards keep themselves current. The visual boards a machine draws for you now rebuild themselves straight from your data — when you open one, right after a button changes something, and when the app starts — so what you’re looking at is always what’s actually there, with no rebuild step to remember and no gas spent doing it.

Forge is 1.0. The beta label existed to cover three honest complaints: janky, slow, and more expensive to run than it should be. One by one those stopped being true — the fuel gauge tells the truth now, the type renders right everywhere, and the everyday clicks stopped costing gas at all — so tonight the label caught up with the software. Version 1.0.0, both platforms, one release. Existing installs update themselves on the next restart, same as always.

Checking a box is free now — and any machine can offer free buttons of its own. Completing a to-do, pushing its date, deleting it: those are now plain buttons the app performs itself in milliseconds, for zero gas — no AI involved, because none is needed to flip a checkbox. Underneath is something bigger: any machine can now declare its own set of these mechanical buttons in a small file the app reads and enforces — strictly bounded to the machine’s own data, never its instructions, with anything malformed ignored calmly. And a confession that belongs on this page: the release check for this exact feature stopped tonight’s 1.0 cut — it caught the buttons promising to appear somewhere they couldn’t. The promise got narrowed to what’s true instead of shipped broken, and the cut ran clean the second time. The gate doing its job on launch night is the whole reason the gate exists.

A whole family of font bugs died tonight, in one pass. The same defect had bitten four times under four names: machines rendering in a fallback font instead of the house type, because the one file carrying the real fonts either never shipped, wasn’t linked, or was taught wrong in four different places. The root cause was humbling — the updater delivered everything except the fonts file every page links. It ships now, builds check for it before declaring victory, and a missing copy repairs itself or stops loudly instead of silently rendering the wrong type in a customer’s world.

Big cleanups run as one batch instead of a hundred small trips, and your conversation survives a restart. The inbox sweep now files everything in bulk by rule — one entry per destination, one refresh per machine — instead of touching items one at a time, which was quietly the most expensive habit in the whole system. And quitting the app no longer forgets where you were: reopen a machine’s tab and the conversation picks up where it left off.

The thing I run my whole shop from is now free to take. I talk into my phone and a room full of agents goes to work — each one on its own job, all of them in one window I can open from the couch. That’s the code I actually use every day, not a version cut down for sharing, and it’s on the free shelf now with the full documentation: how to stand it up, how it’s put together, and an honest page about what it doesn’t protect you from. Take it, change it, sell what you build with it.

The map and the archive now carry a live board, written by the shop itself. Every fifteen minutes, the same system that runs my day publishes what it’s actually doing — what’s being worked on, what’s waiting on me — onto the map and archive pages. It writes through a checker that refuses to publish anything that shouldn’t leave the building, and the checker earned its keep on day one by refusing a line that carried somebody’s name. That’s the posture I want: the window is real, and the glass has a filter.

I fixed the archive page by hand, and then a generator quietly un-fixed it. Two things broke at once on the archive page — the live board went blank and the phone menu disappeared — and both had the same cause: that page is built by a generator, and the generator was still carrying old template text, including a phone-menu bug I’d already fixed on the page itself three days earlier. The morning rebuild regenerated the page and calmly put the bug back. Worse, the missing board slot made the board publisher refuse to publish anywhere — it fails closed on purpose — so the map’s board went stale too. Both are fixed in the generator now, which is where the fix should have gone the first time. Lesson written down where I’ll see it: fixing a generated page by hand fixes it until the generator runs again.

I found two tools I’d built last week that could never actually run. Part of my setup lets an agent do something real — send a thing, publish a thing — but only for a single turn, and only when I say so out loud. Two of those abilities got written, tested, and then never added to the list of what’s permitted, so they sat in the folder looking finished and were unreachable the whole time. One of them was the undo for another one, which is the worst possible one to be missing: I could create something and had no sanctioned way to take it back. Nothing warned me, because nothing was checking. So I wrote something that checks, it found both in about a second, and it ships with the free download so you can run it against your own copy.

Forge runs on Mac now. Apple Silicon, signed and notarized — the install dialog says “Apple checked it for malicious software,” which took days of pipeline work to earn. Same release as Windows, and one activation code works on either. Before releasing I ran it on real rented Mac hardware, and that run surfaced five real bugs no customer ever saw: a downloaded engine that arrived without permission to run itself, the app failing to recognize its own install location — which threw a permission card at every step of setup — and a scripting-language difference between Windows and Mac that made every board tool read whole files as one long line while looking perfectly fine to every static check. “It parses clean” is not the same as “it behaves the same”; that one only fell to actually using the thing. The final check was a wiped machine, a fresh install, and “set me up”: about six minutes to a furnished world, zero permission cards.

The fuel gauge did month math with lifetime numbers. August 1 was the first monthly rollover any customer had ever crossed, and their gauge greeted them with a full reading against a fresh tank — it was computing the month’s spend from all-time usage. Display only: nothing ever blocked anyone from working; the number was just wrong, on the one morning it mattered most. Fixed the same day. (The gauge has a second, separate habit of serving stale readings that I’ve diagnosed and not yet fixed — it’s next on the bench.)

A customer’s Forge flagged an email from me as a suspected prompt injection — and I’m delighted. Their setup routes action-item emails into Forge’s inbox, and my reply to their earlier bug reports landed there. Forge looked at it and balked: the message claimed to be from me but arrived from a personal address the agent had no way to verify, it echoed a configuration conversation word for word, and its actual ask was to change how the agent processes that very inbox. So the agent did exactly what it’s built to do with instructions that arrive as data: it acted on nothing, left everything in place, and handed the decision to its human. The email really was from me, and the advice in it was fine. Doesn’t matter. An instruction that shows up in a file is data, no matter whose name is on it — and that rule just held in a paying customer’s world, with my own name on the test.

A customer’s first try at voice transcription died on a dead download link — my fault, and an embarrassing kind of fault. The transcription tool fetches a media converter the first time you use it, and I had pinned that download to someone else’s rolling build channel. They clean up old builds on a schedule, so my pinned link quietly stopped existing — and because the download only happens on first use, a weeks-old install could hit it out of nowhere. Nothing on my side had ever asked “is that link still alive?” The converter now lives on my own release channel, which never rotates, and the fix shipped in a new release the same day the report came in. The rule that came out of it: never pin a download to a channel you don’t control.

Three pages of my site hid their menu on phones and offered nothing in its place. A half-built hamburger menu, left behind as a fossil: the pages dutifully hid the normal menu to make room for it, and the hamburger itself never existed. Every page now uses the same two-row menu that simply wraps on small screens. (This one turned out to have a sequel — see August 2.)

The site became the shop. The homepage now leads with the whole operation — a map of how everything runs, a public archive of every daily issue, a free shelf, and the fixes page you’re reading. The sweep that built it caught two things worth owning: one dead link, and a demo page that unfurled as a giant red permission card whenever anyone shared it, because it had no preview metadata. Both fixed before most people ever saw them.

The release carrying the July 28 fixes below went out — built and signed entirely by the shop’s own cloud machine. Everyone on a current install picked it up automatically the next time they quit the app. One deliberate detail worth showing: the machine that builds and signs a release holds no key to publish it. Publishing happens separately, from my desk. Two machines, two keys, on purpose.

Forge is out in the open now, at 0.9, and the buy box says so. I'd been holding the launch for a 1.0 that kept sliding — five days past the date I'd set, chasing a polish bar that has no finish line, only an asymptote. My own rule is that the gate is working software, never the date, and that rule cuts both ways: it forbids shipping something broken because a calendar says so, and it equally forbids sitting on something that works. So the door opened at 0.9, labeled honestly as a beta. Wiring that label in turned up one buy button that went straight to checkout without ever passing it — somebody could have bought without seeing the word. Rerouted; every path sees it. And the fine print finally tells the truth about the install warning Windows shows you: early installs are exactly what makes that warning go away for the people who come after.

A brand-new world could get stuck on its own front step. The worst kind of bug, because it only hit people opening Forge for the first time: first-run setup would finish furnishing your world, and then your world's own checker would go on insisting it wasn't done — forever. My first fix was correct and wasn't enough, which a clean-machine round proved by watching the loop survive it. The real cause is the embarrassing kind. The checker looked for a phrase on your home page, and the home page contains that phrase twice inside its own code — so the check had been reading "yes, finished" in every world that ever shipped, whether it was true or not. It reads a mark on disk now, one that only the finished job can leave.

Tools that belong to the Professional tier had been installing on any seat at all. Of the eight machines that come in two versions, exactly one actually checked which seat you were on — and that was the one I happened to test, which is why the whole thing looked fine. The rest installed the Professional version on a Personal seat without a word. That's the upper tier's contents going out the door for nothing, and it's my mistake, not a clever thing anybody found. It's closed at the point where the install is actually written — including a suggested correction that came back from my test machine and was itself wrong, which would have left the hole open while making it look shut. The catalog now greys out what your seat doesn't include instead of quietly handing it over.

I took the collection shelf off the shelf. A live test of the thing it's supposed to be best at — drop in a photo of your books, get a shelf — hit six permission cards for a single book, then five more for one lookup, and produced no cover art for any of it. The cause was mine, in the app: it promised a tool one up-front approval for the sites it needs, and then had nowhere to keep that approval, so every last fetch asked you again. First I pulled the internet lookups out of the tool entirely, photo only. By late that night I pulled the whole tool off the catalog — twelve machines on the floor became eleven — because shipping it in that shape was worse than not having it. Everything I cut is written down with the exact place to restore it from. A cut you can't reverse isn't a cut, it's a loss.

Five of eight tools couldn't reach their own pages. A tool's front page is supposed to be the door to everything else it made. On five of the eight I checked, that front page linked to none of its own pages — you'd land there and stop. The one tool in the test world that was wired up properly end to end was the one Forge had built live from a plain sentence that afternoon, which is a compliment and an indictment in the same breath. There's a checker now that starts at each tool's own dashboard and fails it if any of its pages can't be reached from there. From the same pass: the garden log stopped opening as raw text and opens as a page, the way everything else does.

Fifteen minutes, three books, and nothing on the shelf. I ran the collection shelf's headline trick on myself: drop in a photo of three books. Fifteen minutes later it stopped with zero books on the shelf. All of that time had gone to cover art — eight minutes of it out looking things up on the internet before noticing that the covers were sitting right there in the photo I'd handed it. And when I stopped it and asked for whatever it had so far, the next turn started over from the photo, because nothing had ever been written down. Fifteen minutes of work living entirely in the conversation, and stopping cost all of it. The rule that came out of that, and it now applies everywhere: records first, dressing second. Adding things writes them down and redraws your shelf inside the first minute, the pretty part follows after, and progress is real files from minute one — so stopping costs you the last step instead of every step. The same photo, run again after the fix, was three books on a handsome shelf in about three minutes.

Adding a tool from the shelf is instant now, and it doesn't spend your gas. Installing something off the shelf used to be a job the agent did by hand, minute by minute, on your meter. It's a plain copy now: one run put nine machines and 228 files in place in well under a tenth of a second, for nothing. Testing it against the real catalog instead of a tidy stand-in is what earned the day — it turned up tools whose doors silently didn't install, one that comes in two versions and installed itself into the wrong home, and a card that landed in the wrong slot on the home board, which was only ever going to be visible by drawing the board and looking at it.

Your tools got a lot lighter, and they look exactly the same. Every page Forge builds had its typefaces baked inside it — seven and a half megabytes of them across the whole shelf, carried around by every page. They live in one place in your world now and the pages point at it. I proved every page still renders pixel for pixel identical before shipping the change, with a comparison tool I first tested by deliberately feeding it the wrong font to be sure it would notice. Then the catch that mattered: I'd changed the pages and not the instructions that build pages, so the first tool you rebuilt would have hauled all seven and a half megabytes right back in. Both fixed, so what ships and what gets taught finally agree.

The "lost your code?" box on my site had been broken for thirteen days. You put in the email you bought with and your activation code comes back to you, no waiting on me. Except it didn't — it had been quietly failing that whole time. The reason is worse than the bug: I'd tested it by sending a code to my own address, and my own address is the one address that always gets through from where it sends. A test that can't fail isn't a test. It works now, checked from an address that isn't mine — and if you tried that box in the last couple of weeks and heard nothing back, try it again.

The pages Forge builds got about nine times lighter, so your gas goes further. I ran out of gas partway through a day of using my own product, which is a good way to find out where it goes. The accounting was blunt: one page weighed roughly forty-five thousand tokens of the agent's attention, and eighty-some percent of that was font data baked into the page and re-sent on every single turn. Typefaces now sit in one place in your world with the pages linking to them; a page fell to about five thousand, and installing a tool came down to roughly a third of what it had cost. The honest footnote: when I measured again afterward, the wall clock had barely moved, because the part I trimmed was never the slow part — the actual work is. I'd rather write that down than let the good number stand there by itself.

Forge now checks that a page really paints, because three green ones didn't. Three broken things passed every automatic check I had and were caught by me opening the app and looking: a page that displayed its own blueprint instead of drawing the thing, a home board drawn from a pattern that had fallen behind, and every link inside every page silently dead — that last one because a rule written to find a page's head section was also matching its header. All three slipped through because my checks were reading files rather than looking at the result. There's one now that renders the page and reads the words a person would actually see on it.

Forge is free to download now. The door price is gone. You download the whole software, open it, and look around everything — the boards, the tools, the catalog, how it's all put together — without paying anyone anything. The agent is the one part that sleeps until you have a seat, because the seat is what pays for the AI it runs on. I've wanted it this way for a while: you shouldn't have to take my word for what this is. Now you can just go see.

There's a trust page now, written for the person who has to say yes. Your IT department, your skeptical friend, the one sharp person in the office who checks these things. It walks through exactly where your data goes — the complete list of what the app ever sends me, field by field, so you can check it against the wire yourself — plus what happens if something ever happens to me, and the parts that don't flatter me. It's linked from the fine print on the front page, and nothing on it is marketing.

Trying the agent without a seat gets you an invitation, not a padlock. If you're looking around on the free download and you ask the agent to do something, the card that comes up tells you plainly what a seat is, what it costs, and that everything you ever build stays yours in your own folder — and if you buy one, it wakes up right there, same world, no reinstall. There isn't a lock icon anywhere in the app. That's on purpose.

Turning your gas back down can't strand you anymore. The plan was always that a heavy month should be easy: flip up for more gas when you need it, flip back down when you're done. The trap was in the flipping down — done mid-month, it could cut off gas you'd already paid for, instantly, with no error anywhere. Now a down-shift simply waits for the month to roll over and lands then, while a shift up still happens on the spot. Boring plumbing, weeks in the finding, and it's what makes the whole up-and-down promise safe to actually use.

Everyone already inside got a bigger tank today, at no change in price. One of my first customers hit the bottom of his gas allowance this morning — he's been building hard, which is exactly what the first month is for. So every existing seat's included allowance got widened today, on me. When the economics let me make the tanks bigger, that's how I'll always spend it.

The included AI got a serious upgrade — it runs on Claude Sonnet now. The old brain was capable, but under pressure it had one bad habit: when it wasn't sure of something — a name it couldn't quite hear in a recording, a number it couldn't fully trace — it would sometimes fill the gap with its best guess instead of stopping. The new one stops. In the head-to-head testing that decided this, the moment that settled it was small and telling: asked to name a meeting's chairperson from a recording that never actually says her name, the new brain refused to guess and flagged it for a human instead. That's the behavior I want handling your real work, and now it's what every seat runs on.

Tools you build yourself now carry the real design, not a stand-in. The pages Forge builds are set in particular typefaces I chose on purpose — but it turned out the tools you built on your machine were quietly falling back to whatever fonts your computer happened to have. Mine looked right; yours looked almost right, which is worse. The cause was buried in the instructions the app hands its own builder — one line literally told it to use system fonts, an old note from before the design existed. Fixed at the source, so every tool built from now on carries its design with it, and there's a checker now so this particular "almost right" can't quietly come back.

The scary red warning cried wolf on ordinary search commands. A customer sent a note that said, politely, this caution box looks wrong — the file it's pointing at is inside my Forge folder. He was right. The watchdog that scans commands for file paths saw a search pattern — the kind with doubled backslashes, common as dirt — and read it as a network path reaching outside your world. Here's why a false alarm matters more than an annoyance: every red card that's wrong teaches you to click Allow without reading, and then the one that's right gets waved through too. The watchdog now knows what a real network path actually looks like; the genuinely dangerous shapes still go red, and his exact command is in the test suite so this one stays fixed.

If your Forge folder had an underscore in its name, the app treated its own memory like a stranger's. A folder named something like My_Forge meant a permission card every single time your agent tried to save a note about you — and quietly worse, those notes were being filed outside your world folder, where your backups would never see them. The cause was a one-character disagreement between Forge and the engine underneath it about how folder names get encoded. Rather than guess, I read the engine's actual rule straight out of the program and matched it exactly. And the fix cleans up after the bug: next launch, any memory that got stranded outside quietly comes home to your world, where it belongs and where it backs up.

Forge reading its own program files no longer asks your permission. Three notes in one week said some version of the same thing: why am I approving "Forge reaching outside your world" when the path is the Forge program itself? Fair question. The answer that shipped splits it down the middle: reading its own shipped code — which is what updates do to bring your tools current — is quiet now, because nothing of yours is involved. Changing those program files still gets a warning card, same as ever, because rewriting the app is the updater's job and nobody else's.

A bug note can carry up to three screenshots now. Someone had several pictures of one problem and the box made him pick his favorite. Now you can attach up to three per note, remove one and swap another in before sending, and everything arrives together. Small thing; less friction on the one channel I most want used.

The Welcome tab finally notices you already named your Forge. It kept showing the "give me a name" task over a box that already held the name — and one careful customer skipped it rather than risk renaming. Now, once named, the card reads as done and says so plainly: the name is yours, the box below is for changing it, and it will never change on its own.

The path across the top of a tool reads like a path now. A sharp-eyed note pointed out the same little dot was doing two jobs — sitting inside tool names and separating the steps of the breadcrumb trail, so the trail read like one long title. The trail now uses a proper chevron (›) between steps, and the dot stays where it belongs, inside names. His words: consistency and contrast matter. Agreed.

Forge now tells you what it's doing while it works. The worst report in the box so far: an update that ran ten minutes and showed nothing at all until the end — and an earlier one that never came back, after a long silent wait. Working a long time is sometimes honest; looking dead while doing it is not. So the little "working" footer grew up. It now reads "Forge is working on it," a long update says up front that it might take a few minutes, and as the work moves the footer follows along in plain words — "Backing up your world first…", "Refreshing your commands…" — with the timer ticking beside it and the Stop button in reach the whole way. Before this shipped, a fresh copy was installed on a clean test machine and a real ten-minute update was watched end to end, screenshot by screenshot. That watching caught the follow-along line freezing partway through a long job — fixed the same hour, and then it shipped.

Your own tools can put a live badge in the top bar now. The to-do list and the inbox have always had their little counters up top — "3 due today" — but those were mine, wired by hand. Then a customer building his own tool asked the obvious question: why can't mine do that? Now it can. A tool declares its badge in one small file that lives in your folder, the app reads it and shows the count, and a tap opens the page you named. Because the file is yours and the reading rule is frozen, the badge keeps working through every update — that's a promise built into the design, not a hope. And if the file's ever written wrong, the bar simply shows nothing rather than a wrong number: a quiet bar beats a lying badge.

An interrupted update now finishes itself. After Forge updates its own program, it quietly runs one follow-up to bring your world's tools current. If that follow-up got cut off — the computer shut down, the connection dropped — nothing ever said so, and your tools could quietly fall a version behind with nobody the wiser. Now the app keeps a note of unfinished business: next launch it simply finishes the job itself, and if it can't after a second try, it tells you plainly and waits for your word. Nothing silent, nothing lost.

Ctrl+click a link inside a tool and it opens in its own little window. This one was asked for this morning and shipped tonight. Michael wanted two to-do tasks open at once so he could compare them side by side — and in Forge, each tool lives in one tab on purpose, so opening a second page meant losing the first. Now any link inside a tool answers Ctrl+click (or a middle-click) by popping open in a plain reading window: no chat, no permission cards, nothing it can touch or change — just the page, set wherever you like, next to whatever you like. Worth saying: the very first real test click found a crash when the window closed. That's exactly why nothing ships here until a human hand has actually pressed the thing — fixed before it ever reached you.

Two of the built-in checkers had my computer's driveways baked into them. The tools that double-check your home screen and your links carried a couple of quiet assumptions about the exact machine they were written on. Nobody hit it yet — these were straightened as part of making sure every piece of Forge runs wherever it lands, not just where it was born. The boring kind of fix, which is usually the kind that matters in a year.

The Welcome tab stopped repeating the sales pitch. It used to carry a little "the deal, short version" paragraph — one guy, a bug box instead of a help desk, no refunds. That belongs on the website, where you decide whether to buy; inside the app it was furniture from a conversation you'd already had. It's out. The bug box itself hasn't moved an inch — it's in the gear menu, same as always.

Most of today came from one person's testing. One of my first customers spent the last two days actually working in Forge — running his to-do list, importing his own stuff, pushing on corners I hadn't — and dropping a note in the bug box every time something fought him. Nearly everything below traces to one of those notes. This is the whole support model working exactly as designed: no help desk, just a box, read by me, worst first.

Ctrl+W closed the entire app instead of the tab you were on. Thirty years of browser habit says Ctrl+W closes a tab. In Forge it took the whole window — every tab, mid-thought. The culprit turned out to be a hidden default menu the app never asked for, quietly carrying "close the window" on that shortcut. Ctrl+W now closes just the tab. And while I was in there I found that same hidden menu also let Ctrl+R wipe your open tabs by reloading the screen — that's gone too.

The window refused to share a big monitor. Forge wouldn't shrink enough to take half of a wide display, so putting it side by side with your browser meant windows overlapping each other. It now docks to a true 50/50 split.

Drag the text box taller. Writing something long into the chat meant watching your words scroll out of view. Grab the top edge of the box and pull — it stays the size you set. (The box was also supposed to grow on its own as you type; a layout bug had quietly turned that off. Both work now.)

The bug box threw away your unsent notes — while promising the opposite. Its own copy says "add each one, send the whole batch." Close the popup partway through and the batch was just… gone. Your notes now survive closing the popup, closing the app, everything — they're there when you come back, right where you left them.

The bug box has a blue option now: "not a bug, just an idea." People kept filing good ideas as low-severity bugs because those were the only three colors. Ideas get their own lane now — and on my side they file below real bugs, so a broken thing always outranks a wish.

Your agent has a name now, and the app uses it. He'd named his agent early on — the name lived in conversation, but the home screen still shouted the generic greeting. There's now a "Give me a name" card in the Welcome tab, and once you've answered it the header greets you properly. If you've been running Forge a while, the Welcome tab will reopen once to ask — that's it doing this, not a glitch.

"OP" is now "About You." The page where Forge keeps what it knows about you was named after my internal shorthand, which meant exactly nothing to anyone else. Every place the app says it — and every place your agent speaks it — now calls it your About You page. Same page, same contents, a name a person would actually use.

A tab you're not watching now taps you on the shoulder. If Forge stops to ask permission on a tab that isn't the one you're looking at, that tab lights a small dot — so a job can't sit silently waiting on you behind your back.

The mic tells you it's working after you let go. Between releasing the button and your words appearing, there's a beat where the recording is being turned into text — and the button just sat there looking finished. It shows a little working spinner through that beat now.

Running out of gas could show you my plumbing. If your monthly gas ran dry mid-answer, the raw error could surface an internal link from my fuel supplier — harmless to you, but it's my back office and it has no business on your screen. The out-of-gas message is now the calm, honest one, and the raw version is scrubbed at every door it could have slipped through.

The home screen got a guardian, and the guard got smarter. Your home screen and your tools' instruction files are the load-bearing walls of your world, so hand-edits to them now get a calm card pointing at the safe road (the built-in tools that edit those files without breaking neighbors). While building that, we found two ways a command could slip past the safety layer entirely — one sneaky edit shape, one way of hiding a send-out inside a web address — and closed both, with tests so they stay closed.

Forge now double-checks its own work in ways it couldn't yesterday. New self-checks run every time a tool is built or installed: every link has to resolve, no page gets stranded, a dashboard that says "17 items" over 18 files fails on the spot, and an import that quietly dropped a section of your document gets caught by name. These are the boring ones — they're also how a tool stops being able to lie to you about your own stuff.

The doubled "Home" row inside tool pages is gone — everywhere. Tool pages used to carry their own little "⌂ Home" breadcrumb even though the app's bar already has one, and clicking it opened the home screen as a page — a second, confusing "home." Swept out of every tool on the shelf, and the new self-check fails any page that tries to bring it back.

The Attic. From this morning's earlier release: when you're done with a tool, you don't have to choose between keeping clutter and destroying something. Say the word and it's moved to the Attic — off your home screen, everything inside intact, ready to come back down whenever you ask. Actually deleting something can only ever happen from the Attic, with the consequences spelled out, and a second yes required.

An interrupted install could leave the agent guessing — and guesswork nearly rebuilt someone's home screen. If an install got cut off partway (a closed laptop, a killed turn), nothing marked where it stopped, so the next conversation had to improvise the finish — and improvising almost regenerated the whole home screen from scratch. Now every install plants a progress marker the moment it starts and removes it only when every check passes; an interrupted one picks up exactly where it left off. And the home screen itself got a bodyguard: a mechanical check that refuses any rewrite that would drop one of your tools' cards. Caught in my own use, fixed the same night.

The home screen is now edited with tweezers, not rewritten. When a new tool earns its card, the app splices exactly that one card into place and leaves every other card untouched, byte for byte — adding one thing can no longer jostle everything else.

The app now tells you when it's bitten off too big a write. Some failures were invisible: the agent tried to write one very large file, the write came back broken, and it quietly started over — again and again — while the screen just said "working." (That was the forty-minute mystery behind today's brain swap, and it could still happen to anyone on a truly huge file.) Now the app notices the loop and says so, plainly: waiting usually works, and if it's stuck, press Stop and say "write it in smaller pieces."

The download warning found a second way to cry wolf. Also fixed. Earlier today I fixed the scary "your files could leave your computer" card firing on downloads. Testing cover art for my game shelf, I found a subtler version: a download script that also did something harmless with a file — measuring its size — read as if the file were being sent out. The check now looks at what each command actually does instead of pattern-matching the whole script. Real send-outs still get the loud card; I re-ran every one of those tests to be sure.

Help now teaches the escape hatch. Your work is quietly saved as you go — that's always been true — but nothing told you what it's for. The Help tab now leads with it: if things ever feel off the rails, ask Forge to go back to the last good save, or name a time ("how it was 15 minutes ago") and it restores the closest save it has.

Game shelves come with their real cover art now — you don't have to ask. The collection shelf's blueprint told the agent to use stand-in artwork on game boxes (a rule meant for the demo copies I ship, not for your shelf). Now rendering your shelf includes going out and fetching each game's actual box art. Your things should look like your things.

Long answers could take a very long time — on one machine, forty minutes. One of my customers had the strangest version of slow: installing a new tool was quick, but everyday conversation crawled. His agent actually wrote up the bug report itself, and the write-up cracked it: the AI brain on the included plan choked whenever it had to write something long — the work arrived broken, got quietly thrown away, and started over, again and again, while the screen just said "working." Today the included plan runs on a stronger brain (Claude's Haiku model) that writes long things in one clean pass. I measured it side by side before shipping: same gas mileage, so your tank goes exactly as far as it did.

Forge can see pictures now. Drop a screenshot or a photo into the conversation and the agent looks at the actual image — not a secondhand text description of it, which is how the old brain had to do it. That came free with the brain swap above, and it makes "look at this and tell me what's wrong" a thing you can just say.

If your monthly gas ran low, Forge could blame my fuel station instead of your tank. There are two different "out of money" situations — your tank running low, and my supply having a problem — and in one case the app showed the wrong one, telling you my side was down when your tank was just nearly empty. My fault, pointed the wrong way. It shows the honest message now: your tank is low, and here's where to top it up.

Three shelf tools had links that pointed one folder too shallow. The task manager, the garden tracker, and the kids' schedule each carried a link in their blueprints that could land future installs on a page that wasn't there. Straightened before anyone hit them.

Paste a screenshot straight into the chat. Snip something, paste it in the text box, and it lands exactly like an attached file — no dialog, no hunting for where you saved it. I hit this wall myself the same evening the new brain shipped, testing cover art for my game shelf: I had the snip on my clipboard and nowhere to put it. Built it that night.

The new brain was still being told it was blind. An instruction left over from the old brain's era told the agent, on every turn, that it couldn't view images and should use the old workaround instead — so the brain that could see was acting like it couldn't, and the workaround popped a permission card it never needed. The instruction now matches the brain: it just looks.

Downloading things could show the scariest warning in the app. The safety check that watches for your files leaving your computer was too jumpy: it couldn't reliably tell downloading a file from the internet apart from sending one out, so grabbing a batch of images fired the loudest card I have, pointed the wrong way. Downloads now get the calm, true message — something's coming in, nothing of yours leaves — and the loud one is saved for the moments that earn it. A warning that cries wolf teaches you to stop reading warnings; this one matters to me.

Somebody screenshotted a bug instead of shrugging at it, and it turned out to be real. Michael was setting Forge up, gave it a name, and it stopped to ask his permission twice for something it should never have asked about. Most people would have clicked through and forgotten it. He took a photo of it and sent it to me. Nearly half of what's below came out of those two photos and out of the evening I spent with Joe and Mary. If something looks off to you, it probably is. Tell me.

A task that was waiting on you could get stopped as if it had frozen. If Forge asked your permission before doing something and you took a minute to answer — or if it was in the middle of a long job like an update — the app couldn't tell "still working" from "stuck," so it sometimes gave up and started over while it was really just waiting on you. Now it waits as long as you need on a permission, and lets a long job run to the finish. A genuinely frozen one still gets stopped, fast. This one was mine: the safety timer I built to rescue you from a hang was too quick on the trigger.

Forge said "setting up your world" every time it opened, like it never finished. The very first time you run it, it's a little slow while it builds the back of the house, and it tells you so. But that line kept coming back on every launch afterward, so it read as if something were stuck half-done. It says it once now, on the genuine first run, and never again.

On a smaller screen, the chat panel opened too narrow to show its own Stop button. You had to drag it wider to find the button that stops a run — not where you want to go hunting in the middle of something. And a status line could run off the right edge and vanish under the scrollbar. The panel opens wide enough now, and that line wraps instead of running off.

Inside one of your tools, the "Home" link at the top took you out to the main screen — not to that tool's own front page. I kept clicking it myself, expecting the tool's dashboard and getting bounced all the way out. Now the tool's name is its home: click it and you land on that tool's dashboard, where you'd expect to.

The microphone button looked broken when it was really just waiting to be clicked. It starts greyed out because the voice engine is a one-time download — and you kick that download off by pressing the mic. But a grey button with no hint reads as "dead," not "press me." It wears a little download mark now, so you can tell it's asking to be clicked.

The scrollbar in Settings rode up over the title. Small thing, looked wrong. It sits where it belongs now.

Your tools could break their own links, and the checker I built to catch exactly that was only watching half the time. Every tool redraws its own pages when you add something — a book to a shelf, a meeting to a list. Someone added something, the redraw wrote the links one step off, and his breadcrumbs stopped going anywhere. The pages it shipped with were perfect; it broke itself the first time he used it. The checker only ran when a tool was built, never when it redrew itself afterwards, which is most of a tool's life. Now every tool carries a written map of where its own pages sit, and checks every link after every redraw. This was in all but three of them. It's fixed in all of them.

Two pages you couldn't get to. The games shelf and the finished-proposal page both existed, both looked right, and nothing anywhere linked to them — you could only reach them by knowing the file's name and typing it. They have real doors now, and the checker fails any page that nothing links to, so a stranded page can't get past me again.

Forge was asking your permission to write its own notes. It keeps a memory of who you are and what you're working on, and that memory lives inside your own folder — but a quirk of how Windows links it up made Forge think it was reaching somewhere outside. So it stopped and asked. On your very first conversation. It doesn't anymore, and I fixed the whole class of that mistake rather than just the one case.

Adding a tool from the shelf popped up scary warnings about deleting folders. Every tool arrives with sample data in it, and Forge clears that out so you start clean. Perfectly normal — but it announced each one like it was about to bulldoze your work. Joe and Mary sat through a pile of those just for picking a few tools. It's quiet now, and safe (see the next line).

Forge saves your work automatically, now, every time it does anything. There was a save point on your first day and then nothing else until something asked for one. So "don't worry, you can always go back" wasn't quite as true as I'd have liked. Now every turn that changes a file leaves you a save point you can return to.

The permission cards can tell the difference between a search and a leak. Looking something up on the web and sending one of your own files out to the internet used to look exactly the same: the loudest possible warning. When everything is an emergency, nothing is. There are three levels now — quiet for things that stay in your folder, amber for reaching out, and red for the one that actually matters: your files can leave here.

You never got a warning before running out of gas. Not because I didn't write one — because I never plugged it in. The warning was in there, firing into thin air, reaching nobody. So running out was a wall you hit with no run-up. Now you get a quiet nudge as your tank goes down, and a proper heads-up before it's gone.

A fuel gauge. Settings shows how much of this month's gas you've used, and a little light appears on the gear when you're getting low. Your tank refills on the 1st, and everything you've built keeps working either way — only new answers wait.

You never got your code emailed to you. When you bought Forge, your activation code appeared on the thank-you page once, and that was the only place it ever existed. Close the tab and it was gone. Every purchase now emails it to you straight away — keep that email, it's what you'll want the day you set up a second computer.

Lost your code? There's a box for that. Put the email you bought with into the "Lost your code?" box at the bottom of my site and it comes right back to you. No account, no login, no waiting on me to wake up.

Your code is in Settings, too. If you've got Forge open on one computer and you're setting up another, just look it up. Same code, same email — think of it as the family plan. Put Forge on as many of your own machines as you like; you never buy anything twice.

A bigger tank, for the months you run it hard. You can raise your plan any month and drop it back down afterwards, right from your billing page. And you can't strand yourself doing it — if you've already used more than the smaller plan allows, Forge holds your gas until the month is out rather than cutting you off. That was a real trap, and it's shut.

Cancelling says what it actually does. Cancel from your billing page and you finish out the rest of the month you already paid for. Nothing shuts off early. It always worked that way; now it says so, plainly, where you can see it.

The "you're out of gas" message told you two things that weren't true. It gave you a refill date I'd never actually checked, and it told you to email me for a bigger tank — something you can now do yourself in about ten seconds. I checked the date properly. It's the 1st.

A link inside one of your tools could silently do nothing. Forge catches every link before it can take over the window — that part worked. But the half that was supposed to then open the thing you clicked was never connected, so certain clicks just quietly went nowhere. Connected.

I sat with two people while they used Forge for the very first time. Two hours, in the room, watching them buy it, install it, and build something — and I didn't touch the keyboard. Nearly everything below came out of that. It's the most useful two hours this thing has had.

Asking for a tool got you an answer instead of a tool. She described the meal planner she wanted — clearly, in four sentences — and Forge just… wrote her a meal plan in the chat, like any other chatbot. It never built the thing. The better you explained what you wanted, the more likely it was to do this, which is about the worst way to get it wrong. Now, what you say in the Build tab builds you a tool. Every time.

Tools were arriving with every link dead. The machine got built right, the pages looked right — and then you clicked a day on the calendar and nothing happened. Nothing worked: not the buttons, not the trail of links at the top. It's fixed, and I also gave Forge a way to check its own links before it ever hands you the finished thing, so it can't happen quietly again.

Your tools now tell you that you can just say when something's wrong. Both of the broken tools above got fixed in seconds — the moment somebody mentioned it out loud. But neither person knew they were allowed to. That's on me, not on them: nothing in thirty years of using computers teaches you that the right move is to tell the screen it's broken. So now, when Forge hands you something it built, it says so.

The collection shelf was drawing fake covers instead of going and getting the real ones. He built a shelf from a photo of his video games. It looked up every game correctly — and then spent your money hand-drawing little pretend boxes for them. Nobody wants pretend boxes. It goes and gets the actual box art now.

A hole in the safety layer, and it's the kind I'd want to know about. Forge is supposed to show you a permission card any time it steps outside your folder. Ask it about your Downloads folder and it read the whole thing without showing you anything — a shortcut in the way the request was written slipped straight past the guard. It cards now, and I've written tests for every version of that shortcut I could think of.

The permission cards say what they want to do, in English. One popped up mid‑build and he read it and asked me, flatly, "what is it asking me?" — because it showed him a line of code. That's not a safety question, that's a shrug. Every card now leads with a plain sentence, and the ones that leave your folder look nothing like the ones that don't. The code is still there, tucked underneath, if you want it.

Fewer permission cards for routine tidying. The cards that matter only work if they're rare enough that you actually read them. Cleaning up its own scratch file inside your own folder doesn't need to stop and ask you. Stepping outside your folder still does, every single time.

The first question you ever ask is slow, and Forge now admits it. On a slower laptop that first answer took over two minutes of silence, because it's quietly setting up your whole world behind the scenes. It says so while it's happening now, instead of just sitting there. (I've also put a stopwatch inside it, so I can see exactly where that time goes and start cutting it down.)

The microphone was eating your first word. The button turned red before it was actually listening, so you'd start talking into nothing. It now stays amber until it's really recording — when it's red, it's hearing you.

Forge won't let you put your world somewhere that quietly destroys it. Folders that OneDrive or Dropbox keep synced fight with the way Forge saves your history, and it can take weeks to notice. It now steers you to a safe spot instead of letting you find out the hard way.

I audited the whole thing before inviting more people in. Five independent reviewers went over every part of Forge — the app, the tools on the shelf, the safety layer, even my own documentation — and everything they caught got fixed the same day. The rows below are what that turned up.

Starting a message with a dash broke the send. Type a bulleted list — a perfectly normal thing to do — and Forge answered with a cryptic error instead of reading it. Any message works now.

Telling a tool about work made Forge start doing the work. I typed two to-dos into the to-do list's own chat and it rolled up its sleeves and started building instead of adding them to the list. Now, what you type into a tool's chat goes to that tool — it files things first, and never kicks off a big job from there without asking.

Forge knows who made it. Ask it who built this, who runs it, or where your terms are, and you get the straight answer — one person, you own your world, terms on this site — instead of a confident guess.

An About line at the bottom of settings: the version you're running, who built it, and a link to the terms & safety page.

A few quiet back doors now knock. There were some indirect ways a tool could reach the internet, or edit Forge's own instruction files, without showing you a permission card first. They show the card now.

A tripwire on the download itself. New installs fetch one critical piece from the internet on first run. If that ever breaks, I now get an alarm within hours — instead of hearing about it from a confused new customer.

The two-version tools all use the same two words now — Personal and Professional — instead of three different naming schemes depending on which tool you were looking at.

Snap a photo of a team schedule into your phone inbox and it now lands on the family calendar. Before, the calendar never raised its hand for it.

The packing-list maker was on the shelf but couldn't be installed cleanly. Now it can.

Housekeeping: your copy of Forge shipped with a page of my own working notes tucked inside where your agent could read them. Gone.

The box you type in is twice as tall. You were writing into a single line and watching your own words scroll away. Now you can see a whole thought before you send it.

Sweeping your inbox stops asking the same question four times. Reading four files out of your phone folder used to mean four identical permission cards. Now you can say "allow this folder while I work" once, and it's quiet for the rest of the session. It only ever covers reading — writing to that folder still asks, every time.

Some tools come in two versions. Installing one made the other vanish from the shelf, so you couldn't add it. Both stay put now.

A stray dark line ran across the top of the catalog. It was never meant to be there.

A little heart at the top of the window. Click it and you get a note from me about how this thing actually spreads. No ads, no marketing budget — just people telling people.

Before you'd activated Forge, the buttons at the top of the window looked fine and did nothing. If your code wasn't working, the one button you needed — the bug box — was the one that wouldn't open. It opens now.

Clearing the last notice at the top of the window left behind a notice telling you there were no notices. Now it's just empty, the way it should be.

A help tab. There's a ? at the top of the window now. It opens a page of the things that go wrong for reasons you'd never guess — and its own chat, so you can just describe what's happening and have it fixed on the spot.

The bug box got its own button at the top of the window, so you don't have to go digging through settings to tell me something broke.

You can actually come back. The app said you could restart your membership any time, and then gave you no way to do it. Now there's a button, right where you'd look for it.

If you cancel, you keep the month you already paid for instead of being cut off the same day.

The site kept promising a Mac waitlist that didn't exist. Then it existed. Then it did its job: as of August 1, Forge runs on Mac (Apple Silicon) — the download's on the Forge page, and everyone on the list hears from me directly.

The bug box. Flag what broke and how bad it was, add as many as you want, hit send, and the whole batch comes straight to me. It's in the app, and it's on this website too — for the day the app won't even open.

A paperclip. Drop a file into the conversation and Forge actually reads it — PDFs included.

Drop in a voice memo and it listens to it.

The tool shelf inside the app got a real storefront — you can browse everything available, see what it does, and install it, without leaving Forge.

Six new tools landed on the shelf: a garden log, a property book, a family calendar, a business analyzer, a packing-list maker, and a shelf for your books and games.

Six more work tools landed: a meeting organizer, a contract redline reader, a reply drafter, a proposal builder, an SOP builder, and a website builder.

Every tool on the shelf now shows you a live demo before you install it, so you can see exactly what you're getting.

Every tool now carries its own hand-drawn illustration instead of a generic icon. All nineteen of them.

Some demos opened a link that dumped you into a folder full of files instead of showing you the tool. Demos don't carry links anymore.

Two tools on the shelf had no demo at all and showed you an empty page. They have real ones now.

Your kids' schedule can now hand its calendar file straight to whatever calendar app you already use.

The book and game shelves now open a real page for each item, not just a list.

The property tool grew a supplies board and a queue of what needs doing next.

Forge updates itself. No downloading anything, no reinstalling. It tells you an update is coming, then it's just there.

A welcome screen the first time you open it, so you're not staring at a blank room wondering what to do.

You can now pick a tool from the shelf and have it installed for you, instead of describing it from scratch.

A money dashboard joined the shelf.

Opening Forge twice gave you two copies of the app fighting over the same window. Now it just brings the one you have to the front.

The capture inbox board had buttons that looked clickable but weren't, and buttons that were clickable but didn't look it.

When Forge upgrades one of your tools, it now notices the changes you made to it and works around them instead of flattening your work.

Forge takes a snapshot of your world the moment it starts up, so there's always a good state to roll back to.

The app's own look got locked down to one consistent style instead of drifting page to page.

Forge went on sale. Buy it, get a code, install it, and you're running — with nobody in the loop but you.

Pictures stored in your own world showed up as broken boxes. They show up as pictures now.

The app had two scrollbars stacked next to each other. It has one, like a normal program.

When Forge offered to do something and you said yes, sometimes it didn't actually save what it did. It does now. That one bothered me.

Every view a tool builds now shows up as a card on your home board. No more tools quietly making pages you never find.

The whole app got redesigned. No file trees, no folders, no developer furniture — a home board, your tools as tabs, and a place to talk. This is the version you'd recognize.

You can talk to it out loud instead of typing.

When you ask for something, Forge now puts the result on your screen instead of describing it to you in a chat window and leaving you to go find it.

The AI is included and metered on my end, so you don't need your own subscription to anything.

Forge is signed software. Windows can see who made it, and it says my company's name.

A full day of friction fixes — a pile of small annoyances that each made the thing feel a little cheaper than it is.

Forge can run on more than one AI engine underneath, so it isn't hostage to any single company.

The app crashed on startup. That's about as bad as it gets, and it's why I don't promise you perfect.

The home board became real: every tool you own shows up, and clicking one opens it and starts a conversation about it.

Your tools now live in one plain folder instead of being buried in folders inside folders. You can actually find your own stuff.

Tools now tell Forge what pages they have, so the app stops guessing where things are.

Upgrades got rewritten to never overwrite anything you made. They ask first, always.

Tab labels said nothing useful. They say what's actually in the tab now.

Forge now ships with everything it needs to run on a clean computer — proven by installing it on one.

A living status bar at the top of your world — what's going on today, without you asking.

A plain-English cheat sheet of everything you can say to it.

A to-do list and a capture inbox joined the shelf.

Forge notices when files change under it and keeps up, instead of showing you a stale screen.

You choose where your world lives on your own computer, the first time you open it.

Signing in happens inside the app, in one paste. No developer tools, no terminal, no config files.

Highlight anything on a page and talk to Forge about that exact thing.

Pages sometimes drew half-blank and you had to jiggle the window to make them appear.

All the developer-facing machinery got sealed off, so there's nothing in the app you can wander into and break by accident.

Forge would sometimes go looking for files outside your world when it had no business there.

Forge has to actually look at what it built before it tells you it's done. It doesn't get to guess.

The engine. The thing that actually builds your tools when you ask for them, cleanly separated from my own machine so it could belong to someone else.

The first version of the tool shelf, and the first version of upgrades.