For what it’s worth, I haven’t staked my investment portfolio on there being a bubble, I’m just preparing for the worst and doing as much work as I can with Claude before a potential massive rug pull happens.

It took about two weeks of really running it through its paces, and constantly slamming against the limit on it to convince me I had to upgrade to at least the 100/month sub, and at this point I wouldn’t blink to bump that to the 200/month if necessary.

I 100% believe we’re in a bubble, and that this level of compute isn’t sustainable at this price point, but for as long as I have it, I’m going to run it at the redline.

I’m a solo dev working on a project that I’ve just gone full-time on, after about 1.5 years of part time work. It’s a codebase that I laid the groundwork in, and has very well established systems, standards, and constraints.

The work I’m using Claude to do is the exact work I would be doing myself, but it does it at somewhere in the neighborhood of 5-10x the pace I could have. I don’t know that I could get the same rate of production if I managed a team of 2-3 programmers. Right now, it’s literally almost perfect at taking my iterative suggestions, and implementing them at that accelerated pace.

Honestly the hardest part is dealing with the fact that at the end of the day, I have to understand this codebase perfectly (solo dev and all that), so I have to take in changes to it that are also 5-10x the rate my normal intuition would. But, again, the plus side is that it’s implementing them essentially exactly as I would have, as it has ~20k lines of code that I wrote to use as an example.

If I were to hire even one other programmer, I’d be paying well north of 5k/month, and I’d not only be managing a super computer programmer tool, but an actual human being as well. $100/month might as well be free comparatively.

Couple constructive criticisms:

- Is there a pause button that I'm missing? If not, add one, I want to actually play this more but I need to be able to take breaks

- The beginning is too easy. I'm biased as I like difficult games that encourage mastery, but I found myself dying early on runs because I was getting impatient with how slow the early progression is

- I haven't played enough yet to know whether monsters eventually come from the top, but eventually they should, it would greatly increase the difficulty curve - Hitboxes feel a little meh, and don't seem to match the sprites

- If there's sound, it wasn't working for me, which leads to...

- Pump up the juice. You've got a great core loop, but you need the juice. One of my favorite game dev talks of all time would be perfect for you to watch and iterate with (https://www.youtube.com/watch?v=AJdEqssNZ-U)

- Monster diversity. Again, maybe I didn't play long enough yet to get to newer monsters, but from what I can tell the only diversity is their looks, health, and approach angle. Monsters that are faster and incentivize different movement, or that shoot back at you, or blow up after shooting so you have to avoid, etc.

I'll stop there, don't want an absolute laundry list. Keep at it, you've got a unique foundation, it'd be a shame not to polish it up!

There's more here than just the sanitation narrative, she's tapping into the focus Zen puts on the present, that these every day chores ARE the meditation, or in this case, the artistic expression.

What I mean is that traditionally I think peoples' ideas of lookup tables are things like statically baked arrays setup at compile time, or even first thing at runtime, and they never change. But if you loosen your adherence to that last idea a bit, where a lookup table can change slightly over time, you can get a ton of mileage out of a comparatively small amount of memory compared to wasting cycles every frame.

As for the right tool for the job, I've read tons of dev logs and research papers over the years about moving work to the GPU, but this last few months stint of ripping my game inside out has really made me see the light. It's not just lookup tables built at compile or early runtime, but lookup tables modified slightly over time, and sent to the GPU as textures and used there.

Follow this train of thought long enough, and now we're just calling memory writes and reads "lookup tables" when they aren't really that anymore, but whos to say where the barrier really lies?

But that's just like, my opinion, man.

Great article!

I too put Aesprite in this category, but the big one for me is Godot. After years of from-scratch OpenGl projects and dabbling with Unity, I leaned into Godot 100% around 2020, and ever since it has been my #1 joy-sparking piece of software.