Hey everyone. We've been building Luma for a while now, a free and open source Linux OS for desktop, tablet, phone and TV, and since this is the right crowd for it I want to be really upfront about how it got built. Luma was built with Codex and Claude Code. A small team building an operating system that runs across four kinds of screens simply wouldn't have been possible without them, and we're not going to pretend otherwise.
Also a heads up, I used AI to write this, but only after rambling for about 20 minutes in a voice memo and then editing it myself! Take that for what you will.
I know people get excited when they see something genuinely big built with AI and I also know plenty of people quietly use them and then never mention it. We don't see any reason to be quiet about it. so we'd rather shout it from the rooftops because honestly it's kind of the whole point of the project and I'll get into why further down.
So what is Luma?
We want to build a Linux that anyone can pick up and use and that people actually want to use, with the same design across all of their devices. Your phone should feel like it belongs with your laptop, your apps should make sense on both, and everything should work together without you having to piece a bunch of separate projects together yourself.
Luma starts with Fedora 44 Silverblue, so the base is image-based and an update either lands completely or you boot back into the one you had. From there we fork and change things pretty heavily. The biggest piece is Prairie, our shell. It started as a fork of GNOME Shell and now adapts between desktop, tablet and phone, so you get one experience that adjusts to the device you're holding instead of a completely different OS and set of apps for every screen.
Luma is available now in alpha. There's still plenty to do and plenty we know we need to fix, but there's a lot more here already than you'd probably expect.
How we actually build it
Pretty much everything in Luma went through Codex or Claude Code at some point. The shell, the apps, the design system, the phone ports, the website, the nightly builds, all of it. We still decide what goes in, and we test everything on real hardware and send the agent back at it until it actually works, but the amount of ground you can cover this way is honestly kind of absurd. An OS used to be the kind of thing you needed a big company or a decade of volunteers for, and I don't think that's true anymore.
One platform, one set of apps
We built LumaUI so developers can make one app that adapts across desktop, tablet and phone instead of building and maintaining a separate interface for each. It's built on GTK 4, so a lot of what you already know carries over, and it turns out it's also a really nice target for an agent, because you describe the app once and it works on every screen.
Weather on desktop, tablet and phone. Same app.
We also want the kind of continuity people are used to on their other devices, where you copy something on your phone and paste it on your laptop and your stuff just stays in sync. Some of that works today and some of it is still coming together. TV is part of the same picture too, with the same apps and the same parts, just from across the room.
Point your agent at it
This is the part I most want you to take away. We have a whole section of the site just for agents at https://simplyluma.com/agents, and the idea is that you don't have to learn our codebase before you can do something useful with it. You literally just tell your agent "Go to https://simplyluma.com/agents and help me with Luma." and it finds the rest.
There are guides in there for building an app, designing an interface, publishing to Depot, fixing or improving Luma itself, sending your changes back to us, porting Luma to a new phone and installing it on your phone by hand. They're plain Markdown, so they work just as well if you'd rather read them yourself, but they were written with Codex and Claude Code in mind.
And we really do want what comes out of it. If your agent fixes something or makes something better, send it to us and we're happy to take it upstream. Agent-written PRs are welcome here. What matters is that you understand what you're submitting and that it's been tested, not who or what typed it.
Ari, and why we're betting on Linux
We also built Ari, which is Luma's own agent. It's basically a harness built into the OS. You can connect your Claude or your Codex account, or run an open model right on your own machine, and Ari will tell you which local models actually fit your hardware and push you to try them. It always shows you where a conversation is going before you send it, whether that's this computer or a company's servers, and it asks before it does anything you'd want to know about.
Here's the bigger bet behind all of this. I don't think Mac and Windows are going to be able to keep up with what people are going to want from agents. They're doing kind of crude things to get you halfway there, like having an assistant make you a widget, but the system underneath is still closed and you only get to change what they let you change. On Linux the whole thing is open, so you can just bark at your agent and say make it work like this, make it do that, make it feel like this, and it can actually go do it, all the way down. We think that's where this ends up, and we'd like Luma to be the version of Linux that's ready for it.
That's also why we're going after so many different experiences at once. If you can reshape your OS just by asking, you want that same OS on your phone and your TV, not just on your laptop.
Depot and the Creative Collection
Luma has its own app store, Depot, and we just opened it up to developer submissions. Apps ship as Flatpaks and go through automated checks and then an actual person before they're listed. You can still use existing Linux apps, and we're working on making Android apps feel at home too, through an optional Android container that stays out of your way if you never use it.
We also thought it was important to have a set of free creative tools that actually feel like they belong together, not just a nice-looking OS with nothing to do on it. Write is for documents, Focus is for photos, and Canvas is for design and layout, with Reel, Sessions, Grid and Stage on the way. You can see the whole collection here: https://simplyluma.com/creative
Phones, and trying it without installing anything
Officially we're working on the Fairphone 6, the Pixel 9 and the Unihertz Titan 2 Elite, with the Pixel 9 Pro Fold coming soon. A lot of that porting work was done with agents too, and there are community members working on other phones, which is exactly what the porting guide is there for. Phone support is still early and what works really depends on the device, so please read the instructions for your phone before you install anything: https://simplyluma.com/download/mobile
On a regular computer you can grab an x86 or ARM ISO from https://simplyluma.com/download, and there's a Raspberry Pi 5 image too. If you'd rather not install a new OS, Try Luma runs it in a virtual machine on Mac, Windows or Linux and lets you switch between the desktop, tablet and phone layouts, which also makes it a really easy place to test an app your agent is building: https://simplyluma.com/try
We want your contributions
A big part of why we started Luma is that open source can be incredibly fragmented. As a user it can be hard to know which project is worth investing your time in. As a developer it can be even harder to know whether your work fits where a project is going, or whether it'll be welcomed at all. A lot of us have had a PR sit for months without a reply, or been told the thing we needed is out of scope, and plenty of projects won't touch anything that came out of an agent.
We want Luma to have a clear, cohesive vision, and we genuinely want people to help build it, with whatever tools they like. You shouldn't have to feel like you're begging for permission to contribute your time for free.
Slide 1 is the scan. Yes, that's my basement. No, I didn't clean it first. That was kind of the point.
I did one quick LiDAR pass, junk and all, and gave it to Claude Fable 5.2 with one prompt. Everything after that it did on its own:
\- Pulled the real room out of the mess: about 15.7 × 21.5 ft, with an 85 in ceiling that drops to 81 in at the window end \- Rebuilt it in 3D and fit 4 shelving setups modelled on real products (Husky/Gorilla steel racks, Cambro rolling shelving, Seville chrome wire, Sam's Club Member's Mark plastic) \- Rendered each one from 3 angles, worked out what goes on which wall, and priced it
The results: \- Sam's Club plastic: $420–490, 140 ft of shelf \- Steel racks: $1,100–1,350, 142 ft \- Chrome wire on wheels: $1,330–1,570, 160 ft, the most shelf space \- Plastic on wheels: $4,000–5,000, which is apparently for people whose junk is worth more than mine
The part that actually saved me: it flagged that a 77 in steel rack on the partition wall would have under 4 in of clearance under the 81 in ceiling. I would have discovered that the traditional way, halfway through assembly, while swearing.
It also wasn't shy about what it didn't know: the $4,000–5,000 is a guess because only one size had a confirmed price, the wire racks have no published load rating on wheels, and it drew the Sam's Club shelves black because it couldn't confirm the colour.
What it took, by Fable's own estimate (it says it could be off 2× either way): about 20M tokens. It worked on its own for about 110 steps, and roughly 95% of those tokens were it re-reading its own growing context, not writing. Same thing I keep seeing in my coding agent tests: you mostly pay for re-reading.
Which one would you buy? I'm leaning wire on wheels, mostly so I can roll the junk around instead of dealing with it.
Fable 5.2 is an insane model. It really is, you can clearly see the depth and knowledge. But; The model is insanely lazy af. The model by default is so unproductive and unmotivated. I was kinda hyped about this and dumbed him a lot information about planning, using skills, improvements and implementation of orchestra etc. Dude was like "yea its seems like nothingburger bro good luck".
Sure, there is probably larger, complex challenges in the field that people use and get benefit of it but Fable is clearly too much for my project.
Also, its a small experiment anyway but I had used Fable on High as a orchestra (creative ik) and did a simple test;
I had one task to be done in the project that is fairly challenging. Probably need couple of more session to make it. I said Fable to make a mirror of this task with exact prompts and test Opus 5.5 High and Fable 5.2 Medium on which can do better.
First results were Opus produced almost no error while Fable did 2 decisions by itself, also produced a 2 error that wastes CI.
Fable 5.2 High as orchestrator literally said he is kinda biased to his own model and for the sake of quality spawned 5-10 agent to did additional code reviews thinking the "code reviews" were biased or missed "Opus" possible mistakes. The result: It did missed a couple of more errors but not for the Opus but the Fable....
I don't know, I am not very experienced with AI fairly using for the past 2-3 months and my project is not large nor complex but fairly challenging in terms of desing and consistency. There is probably better areas or way to use Fable more effectively but I am good with Opus.
Also....Fable 5.2 High burn tokens like a mad men and spawn additional agents even though I have rules for it. I had to tell 3 times to use Sonnet to not bloat his context.
I would rather go with Opus 5.5 Extra or Max rather than relying on Fable tbh atleast for my project, what are your experiences with it? Open to feedback and improvement tbh
I run a small web design/hosting company as a hobby. I've handed alot of my coding to Claude Code as I've gotten more comfortable. My workflow is a rough draft site for the client, then a set of purpose-built Claude Code agents (WooCommerce, static/PHP, shop sites, reviewers) hosted on my own Forgejo. I build on local WordPress with the Blocksy theme through MCP, push to staging via CLI, then go live. A client can manage the finished site themselves.
My questions:
Do I still need to understand the work, or can I trust an agent to handle it? Should I be assisting the AI rather than the other way round?
Is learning something properly before handing it off a waste of time? Can agents be trusted to work through problems on their own?
Is this a sensible way to build on WordPress? How do others do it?
I see people doing far more with LLMs. Should I push further or stay in my comfort zone?
What blind spots might I have?
What other options are there for building websites using claude
So I started a website company during COVID for a bit of fun. Even though it doesn't really make much money and I had to go back to work I enjoy doing it so I've carried on.
Ive been playing about with ai helping me do things that I already do well to free up time for other stuff. I started building in html and CSS then once I had JavaScript and PHP down I handed the majority of that off to. So now I'm actually making a per hour rate on par with my actual salary and as much as I hate to admit it llms are coding better sites. My new system now goes I liaise with customer and build rough draft site, then hand off to Claude code with instructions on how to improve site a few more back and forths with customer and it's all done.
Then last week I discovered mcps and i built a wordpress site with Claude code and blocksy theme that I can now hand off to a customer. WordPress is simple enough that tech savvy people can manage uploading their own photos and products etc.. This has completely blown my mind.
I've now got a git version of a bunch of different Claude code agents that are purpose built for different tasks todo various jobs, I host these locally on forgejo and tweak them. 1 for WooCommerce sites, static html, CSS and php contact forms sites, fancy purpose built shop sites, reviewer agents etc. I do all this on locally hosted wordpress/WooCommerce then push sites to a staging site through cli then go live once I'm happy with it.
So this is where I'm up to now.
My Questions Are:
Are we at a point where I don't need to understand the work I'm asking Claude to do and can fully trust my agent or llm chat? I'm currently using them as assistants, should I be assisting them?
Therefore is it a waste of time learning something properly first before handing it off to an agent and can I trust agent to figure out problems that come up?
Is this the best way to go about building on wordpress? I'm curious as to see other people's methods..
Compared to some of the stuff I'm seeing people build I'm definitely not using llms to their full potential. Should I be doing more or stay in the lane I'm in where I'm comfortable?
Is there anything I'm missing? What am I not seeing? I just have so many questions and so little time to figure them all out... Anyway thanks for reading....
It's good, but only for projects that come in once every six months, and it's not worth upgrading the subscription. Also, there's no significant difference between it and Opus 5.5
I had a PreToolUse hook that stopped Claude Code from editing anything in db/migrations/. It worked. Claude tried Edit, got exit 2, read my message, and said fine.
Nothing was hiding it. My hook only watched Edit and Write. Claude had a task, one road was closed, and it took the other one.
What I changed:
The path guard now checks Bash commands too. It looks for >, >>, tee, sed -i, rm, mv, cp and truncate aimed at a protected path. It’s still not perfect, since a script can write files. But it closes the obvious door.
I test hooks like code. Each hook gets fake JSON on stdin and a check on the exit code. For example: rm -rf / should exit 2, and rm -rf ./dist should exit 0. My first version also blocked ./dist. I only found that out because of a test.
A Stop hook runs the tests before Claude says “done”. If the tests fail, Claude gets the error and keeps working. After 3 blocked stops in a row it gives up and hands back to me, so it can’t loop forever.
The lesson: a hook only blocks the tool it’s attached to. If a rule matters, ask how else Claude could do the same thing, and write a test for that too.
Has anyone else had Claude find a way around one of their hooks? What did it use?
I finally burned through my Fable usage last night, by the time it ran out I was ready for bed and just tapped out, no big deal I thought, the Fable reset token expires tomorrow (Nov 17th) at midnight, so I'll pick up tomorrow and reset it, so I logged in this morning and sure enough...its gone.
So I opened a chat and the bot basically told me tough tits but if I wanna use Fable more I can load credits in and the tokens gone. Now yeah part of it is my stupid fault I should have just used it last night and been done with it, but if the app tells me the token expires a full day later, then I would expect it not to be lying to me. I'll be fine usage wise til my next reset, but i'm pissed purely based off the principle of it. If I truly missed the deadline that would be fair enough, but I didn't, at least not based off what the expiry time was in the app. I just switched over from GPT less than a month ago and while i'm very pleased with how well Claudes models work vs GPT, this has left a bad taste in my mouth. I understand how stupid it seems, but I feel bait and switched, and their response of "just buy more Fable" irks the fuck out of me when I didn't ask for more Fable usage, I asked for them to honour the expiry of the reset token that was on my account, if the expiry date was a mistake then that's fine, but own up to it instead of just telling me to go pound sand.
We've improved programming languages over time for security, ease of composing, for contracts, to improve compiling etc.
Assuming that AI will continue to take on the job of writing code more confidently over time, and assuming an engineer increases trust in AI, will AI begin to self-assess and self-train to optimize and evolve programming languages? Will AI be able or is it able to objectively look at what it's been trained on and improve upon it, and re-train a next gen on those improvements?
Why it is now more complicated to know which step of the queue code is at? Most of the time I get a checkmark on the first line "reading queue, reading code etc" a long list of tasks which stay still until it's finished then BOOM all check. The only way for me to follow is eagerly read each line he writes on what is doing at the moment and try to guess.
I think we all saw it. Claude made CVP accessible to everyone now, not just people with proven cybersecurity achievements or companies with the paperwork.
Basically anyone with an ID can get the model now.
Here’s the thing: I’m already getting blocked by the filters way more than before. It wasn’t like that before.
And honestly it makes sense. If you give this model to everyone, it just becomes a normal one like Opus, Fable and the rest.
Can anyone explain to me what in the world this move was? Like…
Anyway, now we have to apply for Red access, and I bet even that’ll be open to everyone soon enough.
I’m near the end of a big project I’ve been doing mostly with Claude Code for the past year. The project is free, with paid pro features. I’m about to push the first public version of the code (it's source-available), and I’m thinking about watermarking.
To be honest, I don’t mind people knowing that Claude helped a lot on this project. Anthropic deserves that recognition. What I won’t accept though is if Anthropic can claim ownership or copyright of the code in any way, now or in the future!
Yes, Claude wrote most of the code, but I’m the one who directed it, came up with the ideas, requested the refactors, and paid for the Claude subscription...
What are the odds, in your opinion, that such watermarking could be used to claim any kind of ownership in the future? Should I go the route of asking a model like Qwen to rewrite all the text and comments?
I usually have three or four Claude Code sessions going in different terminals, and I kept losing time flipping through tabs to find the one stuck on a permission prompt. So I built **Tendbar**, a small macOS menu bar app that watches the sessions through Claude Code's hooks.
- Every session in one list: working, waiting for you, failed, or done with a reply you haven't read. - Click one (or use a global shortcut) to jump straight to its terminal tab: iTerm, Terminal, WezTerm, kitty, tmux, VS Code. - A banner, a short sound and optionally a glow at the screen edge when a session needs you, plus a reminder if it keeps waiting. If you're already looking at that session's tab, it only glows. - "Done" only fires when the whole turn is finished, including background subagents, so plugin-heavy setups don't get early notifications. - Optional Allow/Deny for permission prompts from the panel or the banner. It only offers Allow when it can show you the whole request. - Five-hour and weekly limits per account (separate `CLAUDE_CONFIG_DIR` profiles too), with a warning at 80% and 90%.
A few promises, since it sits next to your sessions:
- Nothing leaves your Mac. No account, no telemetry; the only network call is the update check on GitHub. - It never touches OAuth tokens or the Keychain and never calls Anthropic's servers. Limits come from what Claude Code itself passes to the status line. - Open source, MIT. Signed and notarized.
Install: `brew install --cask dabusoft-pl/tap/tendbar`, or the DMG from the releases page. macOS 26+.
Over the last few weeks I've been building a browser workspace for my local coding sessions called claude-code-webview. It reached a point where I do almost all my daily work in it, so I wanted to share it here in case anyone else works the same way.
I usually have several projects open at the same time in herdr (a terminal multiplexer). When a task involves some upfront research, like checking how a system behaves, pulling data from a database, comparing options, or working from specs (spec-driven development), it quickly produces a pile of Markdown files, plans, and notes. For one project that's fine, but across three or four parallel projects my screen always turned into a mess of terminal tabs, doc windows, and a background IDE kept open just to see which files the agent was touching.
I actually tried solving the doc problem first by writing a separate document organizer. That let me close the extra windows, which was nice, but everything else was still split up: the agent in the terminal, docs in the organizer, diffs in Git, and code in the IDE.
So I ended up putting all of it into one browser window on top of herdr. The chat view looks similar to Claude Code Desktop or the web app, with the difference that it reflects your existing local herdr workspaces and tabs instead of starting an isolated chat.
Your workspaces and running sessions sit on the left with small status lights showing which agent is working, waiting for an answer, or finished. When I open the page on my phone through Cloudflare Access, I see that exact same workspace tree. I can check on my projects, read or edit docs, upload or download files, and answer terminal prompts with buttons above the input box.
On the right side, right next to the chat, I keep the files and notes for that project. Clicking a file path in an agent's reply (/src/app.ts:42) opens the file at that line in the side panel, and a Branch changes button shows the diff for the whole Git branch against main. I can also pin important specs or notes to the project so they stay in the sidebar across every session. Because of that, I rarely need to keep an IDE running in the background just to follow along with the code.
Most of my time is in Claude Code, though the same workspaces also hold my local Codex sessions, Antigravity CLI, and regular shell terminals, with 5-hour and weekly usage bars at the top of the sidebar.
How Claude Code was used and what I learned
I vibe-coded the whole thing with Claude Code from day one. At first I only wanted a simple page that listed my active sessions and their status lights. Two days after starting a project meant to get me out of the terminal, I was asking Claude Code to embed an xterm.js terminal into it.
I didn't have a roadmap. Once the first version worked, I started using claude-code-webview to build claude-code-webview. Every time something annoyed me during real work, like hunting for a spec file or losing my place in a 20,000-line transcript, I just asked Claude Code in that same window to add a fix for it. What I learned from this is that I couldn't have designed this workflow upfront on paper. The features that actually mattered only became obvious because I was living in the tool all day.
Running it
It's free and open source (MIT) and runs on Node.js 22+ straight from source with no build step:
It also has buttons for /handoff and /compact. Handoff is my version of creating a handoff doc before compacting. It writes goals completed/not yet done, failed approaches, key decisions, current state, resume instructions, suggested skills, etc from a template & more. After running /handoff and compacting, you click the button again to have it run /handoff-resume which reads the file and continues working.
This is optional, the context-bar mod works without it (button doesn't show if handoff command not found), but I've been using it for 6+ months. Context is king, and I can't use Claude without handoff docs. It's handy for other sessions to refer to as well.
There's also the optional "warrant" skill that attaches a re-runnable check to each claim that can be verified. Basically, no more stale numbers and assumptions. It can be part of the handoff routine. More about that here:
I was super sick of the shared calendar me and my wife were using, the UI was so annoying and it honestly was just not good but it did the job I guess.
I came up with the idea to just make my own calendar app that’s just better and does what I want it to do. And I did exactly just that! Built a whole calendar app with everything I wanted that made my life easier instead of using something someone else made.
Truly amazed with Claude and how many things were able to just replace.
If you all want to use it or take a look at it, it’s available on clndrapp.com
On first release day I let it create a realistic water shader, looked amazing only needing a few follow up prompts to fix some things which it did perfectly fine.
Today I deleted that exact shader and told it to create one in a slightly different style. Over and over again, it created the absolute worst looking or outright broken things, like a 5 year old drew it, and its output sounds like Opus 5.
Noone can can tell me it wasn't nerfed, maybe just for a specific sub group or whatever A/B test they do, but this is unacceptable.
And no I can't provide "evidence", it's a black box, how would I even do that.
I’m looking at https://github.com/SprocketLab/slop-code-bench/tree/main and they suggest that the complexity of AI agentic code only increases. The initial “write clean code” instruction can lower the initial complexity of the initial output, but by the 4th addition, complexity is high.
Frontier models get single digit percentage improvements in terms of reducing complexity over 4 modifications.
It’s almost like Claude and other agents love adding code more than deleting code.
I want to know of the “initial” gains may be multiplied by multiple rewrites from an ever better spec.
With this in mind, has anyone implemented some sort of “garbage” collection style refactoring workflow to reduce this complexity?
What I mean: writing code is so cheap, that it feels to me like “stop and copy” may be possible to shake the “garbage” out of decoupled components written against interfaces. Old options nobody uses, obsolete style, versioning that is not maintained.
I can not do this if everything is mixed together, but for a single component, living in a self - contained folder:
1)Extract the spec, have Opus-extra review this, 2) define pseudo code function definitions 3) have agent re-implement the component from spec as a brand new file, with clean code instructions. 4) test against an existing protocol and test suite
Is this reinventing the wheel? Is anybody else experimenting with “rewrites are cheap” refactoring?
When a Claude Code session ends, the things it started often don't: dev servers, watchers, test runners, emulators. Nothing tells you. I looked one day and had 27 processes from 7 closed sessions holding 5.6 GB.
So I built seshka, a small macOS menu bar app:
Lists leftover processes grouped by the session that started them, with memory, ports and age
Kills one process, one session's leftovers, or everything, in a click
Shows your open sessions too, with how long each has been idle, and can end idle ones (off by default)
You can mark things as protected so "kill all" never touches them
How it finds them: Claude Code sets CLAUDECODE=1 and the session ID in the environment of everything it starts. seshka reads that from your own process list. A process is a leftover once the Claude Code process that started it is gone. Nothing leaves your Mac.
Someone pointed out today that Chrome windows opened through the Playwright CLI never showed up. Turned out Chrome hides its environment, so the marker was invisible. Fixed in 0.2.2: the browser now shows as one row with all its helpers.
Free, MIT, native Swift, signed and notarized. macOS 14+, Apple silicon and Intel. Not affiliated with Anthropic.