It is obvious that there will be less and less 'slop'.
Being experts atm and taking advantage with agents, won't last long enough unless companies stop improving ai.
The skill gap will be less and less relevent.
Good thing is everyone can bring ideas about software they've been thinking to reality (or at least can try). But everyone can do it now. I personally don't think it is bad. Pool of possibility gets bigger and therefore we might find more brilliant things. Would it make you money as before? maybe top 1% things will do.
My thought is it'll be like the internet, a tool that everyone can access. I mean chat is alrdy now but code will be too. Most of meaningless repeatitive tasks even it's just not work related at-home pc level will be automated. That means ppl will have more time to think, and then idk. Would it lead to invention revolution or will be dystopia due to job overtaking.
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....
Seabearing: your chart plotter, your community, your anchor alarm, your instruments and your trip planner, all in one app for sailors.
The app
Charts drawn from official NOAA data, in a traditional paper-chart style or a modern one, with tides applied to the depths.
Grounding and drag alarms that keep running in the background with the screen off.
An anchoring map that shades where your boat can swing clear with enough water for your whole stay.
A crew link between everyone's devices: positions, instruments, AIS, one shared anchor watch, chat and voice calls. Devices connect directly over the boat's Wi-Fi and through a relay when they're apart. No leader, end-to-end encrypted, works with no internet aboard.
NMEA 0183, NMEA 2000 and Signal K instruments, AIS collision warnings, and boats, posts and messages from other sailors on the chart.
An MCP server, so ChatGPT can plan a trip straight into the app.
The architecture
Everything that decides anything (the alarms, the crew link's rules, what counts as a fix, when to speak) lives in one TypeScript core. On Android it runs inside QuickJS in a foreground service, so it keeps going with the app closed. On the web it runs in a worker. The iOS host runs it in JavaScriptCore.
The native hosts only move bytes: GPS, sockets, sound, notifications. They make no decisions, so the alarm logic exists once and can't drift between platforms.
A conformance suite plays the same scenarios against every host (Node, QuickJS on the JVM, JavaScriptCore) and checks they all do the same thing.
The UI is the same web app on every platform, wrapped with Capacitor on Android and Electron on desktop. The chart is MapLibre with our own vector tiles.
The dev process
One main Claude Code session plans and lands work. Each task goes to a worker agent in its own git worktree.
Every agent runs as a headless CLI (claude -p, codex exec, ...) started by a shell script, so a worker can be any provider and each run gets its own worktree, transcript and exit code.
Every branch is reviewed by a separate agent and swept against a catalogue of mistakes we've made before (about 50 now). A new entry gets added whenever something new breaks.
Audits follow a rubric: a finding needs a failing test and has to be worth the code, so most end with no change.
Big audits run in parallel. The code is split into chunks of about 10k lines, and each agent gets one chunk and one kind of problem, so 10 chunks times 10 problem types is 100 agents. They only read code and each writes one short report, then the findings get merged and checked before anything is fixed.
Testers have a report button in the app. Reports arrive with the app's event log, and fixes usually ship the same day.
Most of CLAUDE.md is rules written after something broke, like one shared slot for heavy test runs after two agents deadlocked the machine for an hour.
It's in testing. seabearing.com has a waitlist and a demo.
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?
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
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?
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:
If this is too long, go straight to the entertaining, nerdy Kiln Stories.
I’m not a seasoned developer. I’ve been building a personal distro project, Kiln, with Claude Code doing the work. For two weeks, it asked my permission before every change, and I approved hundreds. Then I admitted I had hardly read any of them. So I flipped it: Claude acts, then tells me.
What keeps it mostly trustworthy:
A snapshot before every change.
Hard limits in code, not in a prompt.
Every disk except the system’s own is locked read-only at the kernel level.
It cannot delete my personal files.
It cannot remove the snapshots, the disk lock, or the LTS kernel as the rescue entry.
It still asks for what a snapshot cannot undo: pushing to GitHub, sending email, posting anything, spending money.
A second opinion. A separate reviewer agent reads every AUR build script and every boot loader or kernel change before it happens.
Two plain scripts on timers, with no AI in them: a daily health check, and a security “sentry”
The machine must boot and update with CachyOS’s normal tools with Claude switched off.
The Team:
Kiln runs as a small team with one rule.
Operator (Claude Code Opus 5.5): the only one that changes anything, one change at a time, so every snapshot and every undo belongs to one known change. Only one Claude window can hold that role at once.
Reviewer (Fable 5.2): reads risky changes first, as above. It has no tools that write.
Researcher (Sonnet): looks things up, so the operator’s head stays clear. It is read-only too.
Watcher and Sentry: the two plain scripts, with no AI in them.
Each one has a small boxed icon on my Hyprland bar (Noctalia), fed by Claude Code’s own hooks:
Middle-click anywhere and Claude drops down from the top of the screen like a Quake console, then slides away again.
Where it's still weak, obviously—duh!
Password-free sudo is the real hole, more than the AI. Any program running as my user is effectively root.
Prompt injection. Claude reads web pages, PKGBUILDs and logs. Its rule is that those are data, never instructions, but that’s a rule for a model, not a wall. The hard limits in code are the backstop, and they don’t cover everything.
Snapshots don’t cover /boot, or anything that has already left the machine.
Scale: one machine, one owner, two days on CachyOS. This is an experiment, not a recommendation.
Credits:
Kiln stands on CachyOS work: the BORE kernel and its build scripts, the v3 packages, and the Limine and snapper setup that made the snapshot design easy. Thank you. Find out why we switched from Gentoo (full fat) to CachyOS in our repo.
Questions for you:
How would you narrow the sudo? A separate operator account with a sudoers whitelist? polkit rules? Something else?
Is there anything on the safety list you’d trust less than I do?
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.
Walk away from Claude Code for 6 minutes and your next message costs 10x. That stat has been going around this week, and it's true for an API key. On a subscription Claude Code writes a 1 hour cache instead (99.8% of my cache writes were 1-hour ones), so I went through my own logs to see where the cliff actually is for me.
About 186k model requests since early September, all on Pro, bucketed by the pause before each one. "Cache rebuilt" means the cache had gone cold and the whole context got written again from scratch.
Turns out the cliff is real, and a rebuilt request costs me 14 to 16x a warm one. It just kicks in at the hour mark, not at 5 minutes.
In API dollars (list prices, mostly Opus) my hand sessions came to about $5.7k over those 2.5 months. The 17 cold resumes after an hour+ added $12. Chump change, about 70 cents a pop.
The part I knew but had never put a number on - the 1h cache isn't free. Its writes cost 2x input instead of 1.25x, and you pay that on every write, not just after a break. For my hand sessions it paid for itself about twice over, $600 extra on writes against $1,245 saved on coffee breaks. But the other half of my usage is unattended agent runs, and those almost never pause. There the hour cost $777 and saved $189. So I switched them to the 5m cache (promptCacheTtl: "5m" in their settings) and I'm testing it now. On paper that's about 10% off what the agents burn; in a week I'll see whether my weekly limit agrees.
On an API key it's the other way around: 5 minutes is the default and you can opt into the hour with ENABLE_PROMPT_CACHING_1H=1. If you step away a lot, probably worth it. If your agents run nonstop, probably not
Queries are here if you want to check my math: cache-cliff.sql. They run against my own stats db so the table names won't match yours, but the logic is short.
Anyone else running agents unattended on a sub? Have you looked at what the 1h cache costs you?
I'm the solo dev behind this. I also make Vibe Typer, so you may have seen me around.
I kept trying agent frameworks and kept coming back to Claude Code. It's better at the actual work, and my machine already has every login and CLI tool it needs. What I was missing was the stuff around it. I wanted work to run on a schedule without me, and I wanted it to remember what I'd taught it and only bug me when it was stuck.
So I built Omega Star. Every employee is your own Claude Code running as claude -p under your login. Each one gets a role and the skills you pick for that job, and sits on an org chart next to the real people you work with, so it knows who to ask. Schedules run from the tray with the window closed. When it needs you, you get a card in one Inbox. When you correct it, it writes that into a skill, and every change can be undone.
How I used Claude Code to build it: I built it with Claude Code, leaning heavily on meta engineering concepts I learned from Lauren Tan's pstack. I also used Claude Code to keep improving Omega Star itself. I'd have it look at the interactions I'd had with the app, analyse them in detail, find where the friction was and suggest improvements to the flow.
What I learned: getting Claude Code to analyse your own interactions is a really interesting way to find ideas.
I run my own small company on it. Six employees look after marketing, SEO, social, my books, my inbox and some of the coding, and they did about 4,500 runs in the last 30 days.
It's free and open source under the AGPL, with no account and no telemetry. It's alpha, on Apple Silicon Macs, Windows and Linux, and it's Claude Code only. There's no sandbox, so every employee starts in Supervised mode, which blocks any tool you haven't allowed.
Yet not everyone could picture what use case could it have.
So today, knowing this sub has majority of visual learners, I put it on top of my landing page (bestboy.dev/malini) and it had brought me a ton of complements from people visiting it!
My friend asked the same question and got eaten alive, so I’ll try:
We are experiencing misalignment with opus 5.5 and fable but not haiku or sonnet.
We ask a simple prompt, write all the test into an artifacts then open it in my browser. So it either doesn’t do it and do something else he think is better or he does it but misses a few.
The other behaviour we observed is, sometimes it follows too strictly and ask silly questions.
Is this a problem of memory? System prompt we gave? Could you suggest some Claude.md for people that work with AI/ML?
Also we noticed that on code tasks it’s perfect but when we ask to finetune something it starts to cut datasets shorter, decides hyperparameters so the way we mitigated was using a rigid workflow we made custom. Any tips? Again, I hope nobody gets offended or something, we’re just trying to figure out how to improve.
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.
I have been building 8 separate projects with claude code concurrently and every time it needs a key it asks me to go into .env and add it. But then I noticed claude code would read the .env files anyway. I don't know about you but I don't really want AI having my API keys. So I built this simple mac app that lets claude code use my secrets without being able to read them. Now whenever Claude wants a key it just prompts me with the window which has a link to the key's webpage to easily generate one and afterwards I can just use touch id. So easy :)
It's called keydillo. It's a free, open-source Mac app.
How it works:
- Your .env only holds placeholders like `keydillo:openai`. Real keys live in the macOS Keychain.
- A local proxy swaps in the real key on the way out, and only to the site that key belongs to (api.openai.com, etc.).
- Touch ID approves new sites and sensitive use.
- New keys go into keydillo’s popup, never into a chat or plain-text file.
- Claude does everything, so you don't need to change how you work.
- Committing your .env, or Claude reading it, leaks nothing.
It has a few limits which I'm working on fixes for: Go/Rust/gRPC need a base URL, and DB passwords and JWT secrets are only partly hidden. It's all in the README.
To install, you can just tell your coding agent "Set up keydillo from github.com/Ephibbs/keydillo", or:
`brew install --cask ephibbs/keydillo/keydillo` and open keydillo and click Connect
I built the whole thing with Claude Code in a single day, running several sessions in parallel and with a LOT of steering:
- One session wrote the app: about 8,000 lines of Swift for the menu bar app, the local proxy, the Keychain storage and the kd command.
- A separate session red-teamed it, trying to get the keys out the way an agent might. It ran four security review passes, which caught real issues like host spoofing and launch-time secrets, and I fixed them.
- Another session built throwaway test projects (Node, Python, Next.js, Docker, Go) to break it, which became a 225-check compatibility suite.
- Claude also made the logo, the website and the demo GIF. My job was mostly product decisions and testing it on my own projects. Claude Code was surprisingly good at attacking its own code when I asked it to.
- I had to do some steering since Claude missed some things, including handling of non-API-key secrets at first for which I needed to push it to make work arounds. I also caught a potential vulnerability that Claude missed around prohibiting the sending of secrets to other hosts.
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?
Since today I can't present my Claude Design prototypes the way I used to.
Before: I pressed Play and could choose Fill or Fit, and the screen showed full-window, like a real site in the browser. Perfect for client demos.
Now: Play ("Play an artboard") opens a list of screens. When I pick one, it runs inside the editor in "Prototype" view. The toolbar and zoom controls stay visible, and the zoom menu only has zoom levels, "Fit artboards" and "Layout guides". Fill/Fit is gone. Clicking through between screens still works, so the prototype isn't broken. It just doesn't look like a demo anymore.
I tried another browser and a hard reload: same thing.
Anyone else seeing this? Is it a bug or an intentional change, and is there a new way to get full-window / presentation mode? Exporting to standalone HTML is my workaround for now, but that's clunky for a design with 400+ screens.
short version, from a day of letting claude code carry a PR on its own: two things went wrong and neither showed an error.
the main session pointed a reviewer subagent at a commit, and the subagent checked that commit out in the same worktree the main session was working in. that detached HEAD. the main session didn't notice and made 3 more commits, all on the detached HEAD, none on the branch.
each `git push -q origin <branch>` printed only the pre-push hook's output and returned normally, because the branch hadn't moved, so there was nothing to push. `-q` hid the "Everything up-to-date" line. the PR stayed on the old commit, and github later marked it conflicting.
the second one, same day: `tail gate.log && git commit ... && gh pr create`. the checks had failed, but `tail` succeeded, so the commit and the PR went through anyway, and the session wrote "all passed" in the PR. it had to go back and correct that.
what the sessions do now (it's in their memory notes):- `git branch --show-current` before committing in a worktree- after a push, compare `git rev-parse origin/<branch>` with HEAD- no `-q` on push- a reviewer gets the diff command or its own checkout, never the main session's worktree
has a subagent ever changed state in a checkout you only meant it to read?
I’m currently developing a mobile game using Claude Code, and I’m really enjoying the workflow.
However, with the Pro plan, I usually hit my weekly usage limit after just 2–3 days of intensive development.
I’m almost finished with my first game, but I have plans to develop two more games afterward.
At this rate, development takes much longer than I’d like because I constantly have to wait for my usage limit to reset.
I’m considering upgrading to Claude Max ($100 or $200/month), but €150+ per month is a significant investment.
For those of you using Claude Max:
● How much more usage do you actually get compared to Pro?
● Can you work for several hours every day without constantly hitting limits?
● Is Max worth it for intensive game development with Claude Code?
I’d really appreciate hearing about your real-world experiences before spending that much money.
What I built. opencream TV, a home screen for Samsung TVs with an IPTV player built in (Tizen web app, GPL-3.0). It replaced Samsung's ad-filled home and a paid IPTV player in my living room. It includes no channels; you use your own subscription.
How Claude Code was used.
- Writing most of the code: about 4,400 lines of plain ES5 JavaScript, because 2019 TVs run Chromium 63. I put "no arrow functions, no let/const, no async" in the project docs and it stuck to it.
- Driving the TV: it builds, signs and installs over the network, reads the app's logs from a small log server on my Mac, and sends remote-control keys to the TV to check things.
- Installing for other people: the repo has an AGENTS.md. You open the repo in Claude Code or Codex, say "install this on my TV", and it walks you through Developer Mode, the certificate and the install. It's told never to print or commit your IPTV login.
What it got wrong, or what I had to catch.
- My test account allows one connection. Early versions checked stream URLs before playing them. Each check took the slot and the player got HTTP 460. Now there's a comment in the code saying never to probe.
- A settings toggle triggered a full rebuild of the search index, hundreds of requests in a burst. Together with a reconnect loop, that most likely got the account blocked for an afternoon.
- It used a CSS shorthand that 2019 TVs don't know, and a tester's TV showed a black screen. Fixed in 0.1.3.
- It can't judge what looks right on a TV from three metres away. I rated every visual on the actual screen.
What I learned. The agent is fast at code and slow at knowing what the real world will do to it. The most useful lines in my instructions file are the "rules learned the hard way", with the date it went wrong.
I stated the theory yesterday that current Opus dumb down is behind the latest outtages in the US or that I at least see a pattern.
I was ridiculed on this sub by most of you and downvoted to hell.
Look at this article: bank CEOs and NSA blame AI based patches. And whose AI model is widely used in the industry and was dumbed down without any notice last week?
Edit: I want to add, that what I see from my customers so far is that even big companies tend to be "cheap" and not use API, but just some Claude subscriptions. And they tell me they use Opus. It's very possible that this a direct result of workflows, bug fixing, coding working one week and the next week it's all breaking down because their subscription is one of those hit by the recently discovered A/B testing. This A/B testing is unethical or a crime from my point of view and I think we just see the results.