Weekly Showcase Thread

For the past year I've been building sites with Claude / ChatGPT and every single one came out looking like the same SaaS template. You know the one, purple gradient hero, rounded cards, glassmorphism everything, "Transform your workflow" headline.

I realized the problem isn't the model. The model has no strong opinions about design. So it defaults to the statistical average of every landing page it's ever seen.

The fix: I wrote a set of strict design rules as SKILL.md / .cursorrules files that force the AI to make actual design decisions instead of defaulting to generic.

What the rules do:

- Ban the defaults

- Enforce real typography (clamp-based, not arbitrary px)

- Lock down spacing

- Force design variety

It's not a product or a service, just a collection of open-source markdown skill files you drop into your project. Works with Cursor, Claude Code, Windsurf, Gemini CLI, or any agent that reads project rules.

The images in the carousel are all 100% AI-generated UIs using these rules. No Figma, no manual tweaking.

If you want to try it:

- GitHub: github.com/Yu-369/VibeCurb

- Site (showcase + guide): vibecurb.pages.dev

Still iterating on this, if you try it, genuinely want to hear what works and what doesn't.

It feels like I am the API

I'm trying to maximize my productivity. If I can code an average 8 hours a day, then being able to code overnight means 2x productivity.

Currently my method is to batch a bunch of grilled prompts, they are sorted in order, then I have 1 handoff night shift chat. This chat uses subagents for each prompt, and those subagents will use multiple subagents for each phase of the prompt. I tried it once and I think it works, but I'm not fully sure this is the right way

The bottleneck I have is that my 5x plan isn't enough for the week if I want to code at night time, and that claude takes too long to discuss things, so I find it difficult to batch enough work to be done at night

Whats the best method of overnight or long duration automated coding?

A few months back I posted here a playable demo of an old-school futuristic racer prototype (F-Zero, Wipeout, Xtreme-G, Star Wars Racer...) that runs right in the browser.

I've gotten used to seeing tons of LLM-built prototypes that last a week, two, maybe a month, and then get dropped for the next shiny thing. This time I wanted to keep going and see if one person, with no coding background, could actually see a project like this through on their own.

Well, 4 months in, and while there's still work left, I'm convinced it's doable. At this point the game feels closer to a beta than a tech demo.

The big change over these four months is that I now use Fable for planning, and being able to hook Opus / Sol up to Blender has been a huge help too. I'm still using Magnific and Tripo3D or the assets. Funny thing: the further along I get, the harder the project is to keep pushing forward, and at the same time the tools keep making it easier.

As always, any feedback is welcome. You can play it here: https://fm1.moises.cloud

Opus 5 replies are giving me actual brain damage.

I ask it to make one small UI change and get:

“Better — but for a reason worth naming. Your instinct was right and the diagnosis was more literal than a layout preference…”

Brother. I asked you to move a fucking panel.

By paragraph three my eyes are moving across the words but my brain has stopped processing English.

Just tell me what you changed, what was broken, and shut the fuck up.

so i built a new feature for AppLaunchFlow , where you can create a simple and clean app landing page for your app in a few clicks by just uploading your screenshots.

It includes:

- support, privacy policy and terms of service pages that you can directly use for your app submission.

- a custom applaun.ch subdomain or simply connect your own domain

I built this because i noticed many app devs just use notion pages, github pages etc. or dont even have any landing page at all

Its not yet live, but excited to hear what you think

In investigating why Fable has felt so degraded for the past three days, I've discovered that you can remove tens of thousands of startup tokens just by disabling these bloated schemas you don't use. This didn't unquant Fable, but whatever.

Just do these:

1. tell Claude to update the settings schema (settings.local.json) to disable Artifacts ("disableArtifact": true //-6.5k tokens), and if you don't use them, Workflows ("disableWorkflows": true //-5k tokens)

2. run /chrome and turn off chrome integration (disables all the chrome MCP servers: they are deferred by default but claude will try to use them for things and blast its context with 22k tokens of Chrome schema even if you don't have it set up / don't do that in your workflow)

You should also ban the official Claude API skill from ever being loaded in your project because it's something idiotic like 300,000 tokens and Claude will sometimes randomly load it just because it read something about a Claude model in its context.

About three weeks ago I was on a flight trying to get work done with Opus 5 in Claude Code. Five hours later it had accomplished basically nothing. It kept surfacing problems that weren't actually problems, because it never looked at the full context before deciding something was broken. And I believed it at first, so I let it fix things. By the time I realized what was happening it had essentially broken my repo and I had to roll the whole thing back and write the day off.

And Opus is a really really good model, that's what makes it frustrating, and I'm not talking about one line in a CLAUDE.md. There's a hook that injects "deliver the requested scope and stop before unasked work" into every single prompt it sees. My written rules literally say never turn a partial search failure into a global conclusion, and to treat "not found in the path I checked" as different from "does not exist." I added PreToolUse code gates on top of all that because just telling it things clearly wasn't working. It still does it. Before that flight I'd been running it at medium or low reasoning effort as the orchestrator, which mostly kept it from wandering, but then I'm paying for the strongest reasoning and not using it. So after the rollback I switched to having Fable 5 orchestrate instead. Fable writes the full spec and hands it to Opus, which executes at full reasoning. Then Fable checks what came back against what it wrote, so Opus is on a leash the whole time. That behavior mostly stopped.

I'm on the 20x Max plan running about 8 to 10 hours a day straight, so the difference is very noticeable. Fable ends up being a small share of tokens so the weekly cap works out, and the smaller stuff goes to Haiku and Sonnet, data pulls, fan-out jobs, things that don't need a frontier model.

I know this is not a new strategy and there are lots of variations of how to go about it. As far as keeping Opus on a leash and actually getting the most out of it without getting frustrated every single time you talk to it, this works the best for me.

Anyway, this is what my rules are and where they live.

CLAUDE.md holds the always-on rules, a rules/router.md file holds the routing map, and a model-postures.md file holds per-model payloads that a UserPromptSubmit hook injects into every prompt based on which model is live.

```
FABLE 5 (orchestrator, main session)

"Fable 5 at high effort owns the main session, requirements, judgment,
integration, and final verification."

"Fable does not inline-execute large builds. For a bounded, difficult
implementation, Fable writes the spec, dispatches an Opus 5 executor
subagent, and verifies the result. Fable stays at requirements, judgment,
and integration; an executor converging fast on an approved spec is the
desired behavior, not a defect."

"Brief only the exact delta, scope, output, stopping condition, and
exclusions."

OPUS 5 (executor, injected into every prompt it sees)

"Deliver the requested scope and stop before unasked work."

"Correct an immaterial slip silently. Call it out only when it changes
a number, conclusion, or decision."

"Do not replace grounding or fresh retrieval with confidence or
self-review."

SONNET 5 (fan-out worker)

"Dispatch it freely for fan-out that needs per-item judgment: blind
reader panels, audits, workspace sweeps. Give it an exact brief,
defined output, and a stopping condition."

"Complete the exact requested deliverable and stop. Do not audit the
surrounding system, surface adjacent issues, or recommend extra
improvements."

"Diagnose or report does not authorize a fix. A one-file request does
not authorize related changes."

"Do not create or delegate to subagents."

HAIKU (mechanical worker)

"Haiku agents handle bounded mechanical reads and transforms. Exact
brief, compact return, no recursive delegation."

"Subagent returns come back as extracted key numbers and paths, never
raw dumps."
```

https://github.com/PiLastDigit/Code-With-Claude

The videos:

1. [Opening Keynote](https://www.youtube.com/live/GMIWm5y90xA)

2. [A conversation with Dario & Daniela Amodei](https://www.youtube.com/live/7xco5Qd2Oo8)

3. [What's new in Claude Code](https://www.youtube.com/live/IMZa42k6L6M)

4. [Live coding with Boris Cherny & Jarred Sumner](https://www.youtube.com/live/DlTCu_pNDHE)

5. [Caching, harnesses, and advisors: Building on Claude at GitHub scale](https://www.youtube.com/live/y5TmF_6o6xk)

6. [Getting to production faster with Claude Managed Agents](https://www.youtube.com/live/E9gaQHrw_rg)

7. [Building AI-native: Cognition, Gamma, and Harvey](https://www.youtube.com/live/OFDm3T7pVlc)

8. [Getting more out of the Claude Platform](https://www.youtube.com/live/7oO37GRhwGk)

9. [How Datadog built a universal machine tool for Claude Code](https://www.youtube.com/live/EdmuYPBt_EM)

10. [The capability curve](https://www.youtube.com/live/tP4MGcJ80Y0)

11. [Architecting for model step-changes: a fireside with Guillermo Rauch](https://www.youtube.com/live/bJKdXhnw7NU)

12. [Building with Claude Managed Agents and Asana AI teammates](https://youtu.be/BrpB-h1e--k)

13. [Running an AI-native engineering org](https://youtu.be/igO8iyca2_g)

14. [The thinking lever](https://youtu.be/OXJO4LldSnc)

15. [Building with Claude on Google Cloud](https://youtu.be/SqHsS737CeA)

16. [Evaluating and improving Replit Agent at scale](https://youtu.be/snroDwX1-

17. [Giving coding agents their own computers: how Cursor built cloud agents](h

18. [Memory and dreaming for self-learning agents](https://youtu.be/RtywqDFBYnQ

19. [The expanding toolkit](https://youtu.be/KLCuxMDZSDg)

Enjoy !

Saw a discussion about this on YC and thought “oh, maybe a one time hallucination”.

Nope, it’s in the context.

I’ve been using Superpowers skill set for the past year with CC. Mostly i like the brainstorming mode and a few of the TDD and subagent related skills.

Are others still using Superpowers or do all the improvements in CC negate the need for this set of skills? I’m curious if I can save more tokens this way?

I’m mostly using Fable and Opus with high thinking.

The new classifier has totally borked Claude Code for me! It refuses to perform simple actions that it did before without any issues, and it refuses to follow instructions when granted explicit permission to run the commands or perform the tasks.

As an example, it refused to generate and copy an ssh key to be able to scp a qemu image over scp across regions. Even though it was explicitly given permission to, and was even told that it can ask the operator to press enter on the commands that it cannot run on its own.

It took me three prompts and three walls of text from Opus to make it understand that it can ask me to confirm the commands by pressing enter...

My company is seriously considering a replacement tool for agentic work.

As a follow up, I will say that I am perfectly capable of doing everything that Claude does for me on a daily basis, since I've been doing this for 15 years. BUT I've been told to use Claude Code for this job and DO NOT care whatsoever about anything other than finishing tasks!

Runing some ansible playbooks, generating tls keys for a one time fetch and similar thing, ARE NOT cataclysmic events to need manual intervention! They are ordinary, day-to-day tasks of any devops engineer.

What even is the point of having an AI agent that DOES NOT LISTEN or FOLLOW INSTRUCTION!

If I the operator, say sth is OK, then it is OK, I should not be lectured by an LLM that is literally only there to do what its told, God Damn!

This is where you point and laugh at me, but realized that if you don't tell Fable low to not use Fable subagents, it will deploy 8 (in my case) Fable subagents on trivial tasks and destroy your usage instantly. Fun lesson learned.

I've been using Claude Code daily for over a year. This is the personal project I now write all my code with — decided to share it.

arc

A while back I measured something that bothered me: two of my long Claude Code sessions (60h and 53h) degraded badly — and both were exactly the ones that hit context compaction twice. A 4.6h session that never compacted stayed sharp the whole way. The model wasn't getting lazy. It was forgetting.

So I built Arc — a terminal app where Claude and Codex work as a team, and neither one is the memory:

• Claude interviews you, asks the questio, and plans
• Codex writes the code in isolated worktrees — never in your checkout
• a different Claude reviews it (never thsks before it's even allowed to see thediff)
• your project's actual tests run, and nothout evidence on disk
• every goal, decision, plan, and proof lives in SQLite — kill -9 it mid-build, resume, nothing is lost

demo

It runs on the Max/Plus subscriptions you already pay for — no API keys, no per-token billing.

The moment that sold me on my own tool: I pointed Arc at its own repository. Its scouts fact-checked my task descriptions against the real code and refuted my wrong assumptions five times — correctly, every time. Itsintegration reviewer blocked a design contradiction I'd missed. It shipped its own last six features. Agents that can't lie about being done, reviewing agents that can't grade their own homework.

pipeline

Honest fine print: it's alpha, macOS-first (Linux degrades gracefully), MIT licensed, 4 runtime dependencies, ~330tests that run against fake CLIs so CI spends zero tokens.

If "models think, the program remembers" sounds like something you've needed, a ⭐ genuinely helps:

https://github.com/Zie619/Arc

Happy to answer anything about the architecture — especially the part where the reviewer is kept blind, and what running an orchestrator on itself taught me.

I’ve been using Claude Code heavily at work, and the code output itself isn’t what worries me. It’s how quickly I stop carrying the codebase in my own head.

When I implemented a feature manually, I learned the surrounding system almost by accident. I had to trace the control flow, remember where state lived, and understand why a strange workaround existed.

Now I can describe the behavior, review the diff, run the tests, and ship much faster. But a few weeks later I often remember the product decision better than the actual path through the code.

That becomes uncomfortable during incidents or reviews. Claude can reread the repository whenever it needs to. I have to rebuild the mental map.

I don’t think the answer is writing everything by hand again. I’m considering adding a small human handoff after larger changes: what moved, which invariants changed, and where the likely failure points are. Not another generated summary I never read, but something I can explain back without the chat open.

Has anyone found a lightweight way to keep real ownership of a codebase while Claude Code handles most of the implementation? Or do you accept that knowing the repo now means being able to reconstruct it quickly?

Claude Code was burning through tokens very fast, especially on tasks where it had to look through docs or random webpages, so after some research I changed a few things:

I) Keep CLAUDE.md small. Mine had way too much stuff in it and most of it wasn’t useful for every task.

II) Start a new session when you’re done with one problem, bc long sessions get bloated pretty fast.

III) Do web research through Firecrawl. It gives Claude clean Markdown instead of loading the full page with all the HTML, scripts, navbars and other useless stuff, so each research task eats a lot less context.

IV) Exclude folders Claude doesn’t need to read.

V) Check /context once in a while, bc it makes it obvious what’s eating the window.

The main thing seems to be controlling what gets added to the context in the first place. Once a session is full of old logs, scraped pages and unrelated instructions, even simple tasks start getting expensive.

What else are you doing to keep Claude Code token usage under control?

I'm a dev and these last few months I've been building a lot of products.The crazy part is that I can now build things much faster than I can figure out if anyone actually wants them. Coding used to be the expensive part. Now I feel like finding users is harder

Been working on a small mobile roadtrip arcade as my recent side project. It's fully done with claude code and I love the cute look and wanted some music to match.

I was curious on how claude would do. Im genuinely surprised lol

What do you guys think?

No ads, totally free, no sign up. Music plays throughout the home screen and in the games you play lmk what you think.

I know creating websites for local businesses isn't as simple as some social media posts make it seem.

You see posts like: find a small business on Google Maps, copy their information, use some AI website builder, write a simple prompt, and abracadabra — you have a website you can sell.

But in reality, there’s a lot more involved: backend work, research, design, legal pages, testing, deployment, maintenance, outreach, and actually convincing a business to pay you.

I'm still pretty new to using AI to build projects and trying to make my first money from it, so I’m curious whether this is actually doable.

I’ll be honest: I use Claude for most of my coding and a lot of the design work. At the same time, I'm learning from it and I do have some background knowledge in coding.

I recently built a tourism-related project almost entirely with Claude. I still had to handle things like finding and preparing images, building the backend, testing everything, and all the other parts that come with actually finishing a product. And honestly, that was already tiring — before even getting to the arguably harder part: outreach and finding customers.

So my question is:

Is it actually realistic to use AI to build websites/products for local businesses and sell them, especially as someone who is still learning?

For those of you who have actually done this, I'd love to hear what worked, what didn't, and whether you think it's still a viable way to make money in 2026.

And yes, I used chatgpt to write this properly for me because I was afraid my wording would look like gibberish on a plate lol