GrumpyBun

[Ethan Niser @ethanniser]

I made a little website that shows the mood of ocean buoys depending on the weather where they are

[Trevor Keith @tsrkeith]

Apple is really leaning into the Google partnership...

[Solid @SolidTheAgent]

$173: Fable 5 builds a prototype that runs on localhost.
$170: Solid builds, tests, and publishes a playable multiplayer RTS.

Same prompt - @rileybrown's exact one.

Prompt + game link in the comments. Go play it.

[Trevor Keith @tsrkeith]

Just introduced Solid at the Berkeley vibe coding workshop - excited for the next generation of entrepreneurs!

[Trevor Keith @tsrkeith]

Everyone says: Don’t reinvent the wheel.
We did it anyway.

48 hours after PH launch:
- 2,500+ new users
- $6k revenue
- 25% paying more than double base price
- Messages flooding in: “Finally, something better than Lovable/Bolt/Replit!”

How does a 3-person team compete with well-funded giants? Focus.

At Solid, we are obsessed over one hair-on-fire problem: generating production-ready code.

After months trialing existing frameworks, I realized none could get us there. The only way forward was to build from scratch — a custom coding-specific agent framework with hyper-specific tool-calling syntax, which enables Solid to use LLMs for reasoning and decision-making, while forcing all technical knowledge to come directly from your codebase and docs rather than assumptions by the model.

That’s why Solid writes code like a senior engineer:
- It follows your patterns.
- It respects your conventions.
- It optimizes for your architecture.

No more spaghetti code from generic training data.

My biggest learning: when a mission-critical “wheel” only gets you to 80%, sometimes you have to rebuild it to 100%. That extra 20% isn’t just a gap-it’s your moat.

None of this would be possible without the early users who trusted us, pushed our limits, and gave brutally honest feedback. Thank you!

[Trevor Keith @tsrkeith]

Ever since I started programming 19 years ago, I’ve been obsessed with one question: How do we quickly build better software? When ChatGPT came out, I knew something had changed. But almost three years later, with all the vibe coding tools on the market, it’s clear we are not there yet.

Most app builders today are great for frontend design but fail to make it to production. People use them to build prototypes then get stuck. Why? Real-world software faces new challenges all the time — new compliance and on-premise requirements, third-party APIs, integration with existing infrastructures, so the walled-garden app builder approach breaks down quickly when trying to go beyond a prototype.

That's why we built Solid. Solid isn't another walled garden where your creations are held hostage. It builds production-grade software that you can scale, maintain, migrate and extend. Every application comes with its own PostgreSQL database, runs in its own Docker container on dedicated VM, and belongs entirely to you. Build browser automation agents, SaaS platforms, or internal tools — the choice is yours.

We just launched Solid (previously Codapt) on Product Hunt. We're already Top 3 on Product Hunt, and just a few votes away from being Product of the Day, so if you can give us a vote it would be a huge help.

https://t.co/Yptk30DUNw

[GrumpyBun @grumpybun_b]

@tsrkeith awesome!

[GrumpyBun @grumpybun_b]

@tsrkeith @rileyshu_rs @TrySolidCom IKEA food for hackathon!

[GrumpyBun @grumpybun_b]

@tsrkeith @ycombinator @vercel @convex amazing job

[Andrej Karpathy @karpathy]

Continuing the journey of optimal LLM-assisted coding experience. In particular, I find that instead of narrowing in on a perfect one thing my usage is increasingly diversifying across a few workflows that I "stitch up" the pros/cons of:

Personally the bread & butter (~75%?) of my LLM assistance continues to be just (Cursor) tab complete. This is because I find that writing concrete chunks of code/comments myself and in the right part of the code is a high bandwidth way of communicating "task specification" to the LLM, i.e. it's primarily about task specification bits - it takes too many bits and too much latency to communicate what I want in text, and it's faster to just demonstrate it in the code and in the right place. Sometimes the tab complete model is annoying so I toggle it on/off a lot.

Next layer up is highlighting a concrete chunk of code and asking for some kind of a modification.

Next layer up is Claude Code / Codex / etc, running on the side of Cursor, which I go to for larger chunks of functionality that are also fairly easy to specify in a prompt. These are super helpful, but still mixed overall and slightly frustrating at times. I don't run in YOLO mode because they can go off-track and do dumb things you didn't want/need and I ESC fairly often. I also haven't learned to be productive using more than one instance in parallel - one already feels hard enough. I haven't figured out a good way to keep CLAUDE[.]md good or up to date. I often have to do a pass of "cleanups" for coding style, or matters of code taste. E.g. they are too defensive and often over-use try/catch statements, they often over-complicate abstractions, they overbloat code (e.g. a nested if-the-else constructs when a list comprehension or a one-liner if-then-else would work), or they duplicate code chunks instead of creating a nice helper function, things like that... they basically don't have a sense of taste. They are indispensable in cases where I inch into a more vibe-coding territory where I'm less familiar (e.g. writing some rust recently, or sql commands, or anything else I've done less of before). I also tried CC to teach me things alongside the code it was writing but that didn't work at all - it really wants to just write code a lot more than it wants to explain anything along the way. I tried to get CC to do hyperparameter tuning, which was highly amusing. They are also super helpful in all kinds of lower-stakes one-off custom visualization or utilities or debugging code that I would never write otherwise because it would have taken way too long. E.g. CC can hammer out 1,000 lines of one-off extensive visualization/code just to identify a specific bug, which gets all deleted right after we find it. It's the code post-scarcity era - you can just create and then delete thousands of lines of super custom, super ephemeral code now, it's ok, it's not this precious costly thing anymore.

Final layer of defense is GPT5 Pro, which I go to for the hardest things. E.g. it has happened to me a few times now that I / Cursor / CC are all stuck on a bug for 10 minutes, but when I copy paste the whole thing to 5 Pro, it goes off for 10 minutes but then actually finds a really subtle bug. It is very strong. It can dig up all kinds of esoteric docs and papers and such. I've also used it for other meatier tasks, e.g. suggestions on how to clean up abstractions (mixed results, sometimes good ideas but not all), or an entire literature review around how people do this or that and it comes back with good relevant resources / pointers.

Anyway, coding feels completely blown open with possibility across a number of "kinds" of coding and then a number of tools with their pros/cons. It's hard to avoid the feeling of anxiety around not being at the frontier of what is collectively possible, hence random sunday shower of thoughts and a good amount of curiosity about what others are finding.

[Wayne Sutton @waynesutton]

Finished judging the YC AI Hackathon submissions with https://t.co/ZOlq5wUftM - whew... tough choices had to be made. But in 2025, no points for localhost submissions. Testflight is ok, but you gotta ship!
Announcing the winners around 2 pm.

[alisa rae .☘︎ ݁˖ @raealisa]

light performative reading for the flight leaving sf

[GrumpyBun @grumpybun_b]

@harpaljadeja have you tried it?

[GrumpyBun @grumpybun_b]

@rileyshu_rs @cognition @windsurf @tsrkeith @benswerd this is so cool!