The Best Model I Couldn't Keep
On June 9, Anthropic released a new model called Claude Fable 5 for everyone with a paid plan. It was the most capable thing they had released to the public, built on the same system as their stronger Mythos model, but fenced in with extra guardrails around cybersecurity and biology. What people noticed first was how it handled long, connected coding work, the kind where you describe a feature in plain words and the model carries the idea across the database, the backend, and the screen without losing the thread halfway through.
Three days later it was gone.
On June 12, the US government handed Anthropic an export control directive that blocked access to Fable 5 for any foreign national, anywhere, and the only clean way to comply was to switch it off for every customer in the world. The stated worry was a narrow trick for getting the model to hunt through code for security holes. Anthropic disagreed in public, said its safeguards had held through testing, and complied anyway. As I write this, twelve days later, the model remains unavailable for everyone, including US users. Anthropic has stayed quiet on when or how access might return while continuing to ship updates to its other products.
However, that short window lined up with the last stretch of something I had been trying to build for a couple of weeks: an internal dashboard the team at my wife's agency now opens every day.
The agency ran the way a lot of small businesses run: a spreadsheet here, notes in some app or notebook there, messages scattered across too many chats, invoices in a folder someone had to remember to open, and a lot of other stuff that messed with my sense of organization. That system wasn't broken, but it wasn't simple, and it didn't do much for organization and productivity. The cost lived in the time spent in the gaps between all those "systems": which clients pay a monthly fee and which were one-off jobs? Where does the content calendar live, and had anyone already covered that specific newsletter topic? Who does what and is it done or not?
I wanted one system that answered all those questions, so I decided to build one.
It's been live and working since last week (I'm not going to share the link here for obvious reasons). Clients and projects sit at the center, each with its assigned people, contacts, social profiles, and attached files. There's a shared calendar for campaigns and deadlines, and a task Kanban board with filters and the usual "to-do", "in progress", "done", etc., with priorities and comments on every card. Pretty much like in Notion, Asana or Trello. The newsletter section has a full text editor for drafting new editions, and holds the full content of each past edition with its published link, so we could finally archive the twenty-something editions already sent. There are also dedicated pages for Finances (with a full financial tracker), Planning, and even a working internal chat with notifications to keep things from vanishing into someone's cluttered messaging app.
I made the decision to keep the stack deliberately "ordinary". This was one of my first real projects after getting back into coding, and I didn't want to make it harder on myself by choosing complicated tools I didn't fully understand yet. The interface is built with React and TypeScript. The data, the logins (with 2FA), and the file storage all live on Supabase, so I don't have to babysit my own server. And it all deploys to Vercel on our own subdomain. One of the aspects that matter most is something no one using the dashboard ever sees: I wrote the access rules straight into the database itself. That means the data decides who can see the clients' sensitive data (contacts, payments, etc.), financial data, or change another member's tasks. Even if someone found a way around the normal interface, the database would still deny them the access.
Ever since I first had the idea for this project, and given the complexity and scope of what I wanted to achieve, I decided to use AI as a "coding partner" because I needed something the team could use as soon as possible. I'm still working through the coding courses and didn't want to spend months building piece by piece in the evenings and weekends. The goal was a working tool now, not a perfect long-term system I would refine over a year or more. There are of course aspects of it that can (and will) be improved in the future, but those are just small details, not core functionalities.
To make the collaboration effective I created instruction files (project context, agents.md, context files, etc.) specific to this project. These files held the goals, the constraints (keep the stack simple, enforce real security, make it maintainable by one person), and the kind of feedback I wanted. With the context loaded, Claude acted as both pair programmer and tutor. It would evaluate whether the idea made sense, explain how it could be built, recommend the platforms and languages, and push back when an approach would be too hard to maintain or too complex for what we needed. I would read the reasoning, ask why it chose one path over another, test the result in the browser, and send back specific adjustments until it matched what I meant. That loop is where most of the speed came from.
I started the prototype back at the beginning of May, or close to it, on Claude Code, using Claude Opus 4.7. It got me to something that worked, but with a lot of refining left to do. The back-and-forth took a couple of days of describing pieces, reading the code it produced, testing in the browser, and fixing what was broken. Then the project sat for a few weeks while other more important things took over. When Fable 5 became available, I picked it back up and pointed it at the last round of changes, and the difference was hard to miss.
That last round consisted of three things:
- The task kanban board needed cards we could drag into a new order, both between columns and up and down inside one, with urgent items pinned to the top by default.
- The newsletter section needed to grow from a plain notes box into a real editor that could hold the full content of an edition and the link once it went out.
- And we wanted to add a few more options to the services we offer clients.
The services change turned out to be a single line in the database, because the services were already stored as data rather than baked into the code. The task kanban board was the real work. I told Claude what good drag-and-drop should feel like: the card you're moving should be highlighted while the others should dim, and a clear line should appear in the gap where it would be dragged to, so you always know where you're about to drop it. The first version came back close, but the visual cues were off. One round of specific feedback and some visual references later, the dimming and the drop line were in place and the board felt right to use. The whole set of changes, including the database migration script I ran myself, went from description to deployed in less than two hours. With Opus 4.7, that same back-and-forth had been spread across several sessions and more days than I'd like to admit, with more stalls while context got lost and I had to explain the same patterns again and again.
I still had to try to understand everything that went into production. I read the changes, asked why it made the calls it did, and kept testing the security setup until I was confident in it. Earlier on, an audit had found a real issue: a normal team account could have given itself admin rights and accessed the clients' and financial data. Fixing it properly in the database took time and wasn't an exciting task, but that's the kind of work that is mandatory for these tools when they hold real client data, or our own.
The dashboard is live now and the team uses it every day. Fable 5 lasted a few days before it disappeared, and I'm back to working with what's still available (Opus 4.8). The parts where I had to read the code, test it, and decide what was sound didn't go anywhere when the (way) better model was used. Some of it I couldn't follow without help and a fair amount of searching. The model builds and teaches, and it's good at both, but the work of understanding each step and ending with something you know start to finish still lands on you. There's no substitute for that.
I've tried every model I could get my hands on these past months, and Fable 5 was the first in a long while that made me sit up. It could hold a messy, multipart change in its "head" and get the shape right the first time more often than not, with less correcting from me than I'd gotten used to. That was the real jump, the reasoning holding together across a long task. I'm half expecting it never comes back in that form, and that would be a shame. My guess is something with the same reach, or more, lands in a few weeks or months, and this whole episode turns into a footnote. I'd be fine with that.
May The Code Be With You! 🚀
Member discussion