TonyAlicea10

Yes those are cool ideas! The push and pull of ideas has been between satire and playability. But skill atrophy is definitely a game mechanic I've been exploring.

There's a probability per-level of mutation.

I've been thinking a lot about how agentic coding is similar to gaming. Risk, reward, gambling, gratification, etc. I've been exploring that by vibe coding some satirical games that aim to reflect what agentic coding can be like in a deadline environment. This is one of those games.

It's Tetris but:

- You have to build a tetromino either manually or have AI "generate" it.

- Generated tetrominoes might mutate after falling.

- You can spend time to "review" generated tetrominoes as they fall to see how they will mutate.

The theme is the risk/reward/pressure of agentic code vs manual vs reviewed agentic code in a deadline environment.

I like to say AI is like the super soldier serum from the MCU. Teams take it and either become Captain America or Red Skull, it depends on what you were to begin with.

The fact that it’s called “the quick pitch” screams Claude-written pithyness pulled from some context that doesn’t match the article’s style (like investment pitch decks).

We don't run our own unit tests on compiled code because it generally can be trusted. LLMs are an extraordinarily leaky abstraction.

Saying "as long as it works and tests pass" suggests that we can test for every possible scenario. We can't. And tests can be flawed on top of it. Which is why an LLM is no more a compiler than a human coder (as you say) is.

I think two things contribute to the trust in LLMs:

1. Decades of generally reliable systems (I trust my calculator because it always says 1+1=2) has trained people to believe what computers say.

2. LLMs "speak" with great confidence, which has, as you say, a psychological effect.

It absolutely might make mistakes. But the skill requires all questions to be based on lines of code with specific line numbers which the human needs to review. That's intentional to serve as a safeguard against hallucinations.

I mean in the traditional software sense. We trust autopilots to fly planes. Would you get on a plane flown by an LLM?

As a tech educator I 100% agree. LLMs are not going to become a "new compiler" where we don't have to worry about the code any more. There's a reason we trust deterministic systems.

I've been worried about this a lot, I even created an agent skill called do-i-understand that's designed for novice devs (and experienced too, because atrophy) where the LLM asks you questions about the PR you're about to submit. I've found it helps a lot: https://github.com/AnthonyPAlicea/skills/blob/main/skills/do...

One way or another, there will be a skill reckoning.

I’ve done a lot of work with the Office file formats over the years, flipping to .zip and messing with the format manually. Lately, because I’ve made courses with 500+ PowerPoint slides with lots of morph transitions, I iterated to find an approach that generally worked with Claude but is never perfect (using the Claude for PowerPoint plugin).

I switched to https://bento.page/ when it showed up here on HN and that’s been much more accurate I think because HTML and CSS is even more represented in training data.

GORILLA.BAS got me into programming decades ago. I made an (admittedly partially vibe coded) homage this year: https://gameswithtony.com/gorillas/

Google switching to hallucinating AI summaries has been to me an absolutely shocking abdication of care for both their users and their own reputation.

It extends beyond search as well. I have had multiple incorrect Gmail summaries that, if I had only read them instead of the actual email, would have resulted in financial harm.

Presentation in what medium? A screen reader? You’re talking the user-agent stylesheet, which is a particular chosen presentation that I can change with my own CSS. I can make a button look like a link.

You’re suggesting aligning to an inherently and deliberately changeable presentation.

The idea is fine, but worry about what an HTML element “looks like” is not a good reason.

> Buttons regularly perform navigations. Clicking a logout button navigates the current page to a logged-out one; clicking a “search” button navigates the current page to the query results.

This seems to conflate appearance with semantics. If an element causes a navigation, I make it a link. Whether it looks like a button is irrelevant, that’s CSS.

I always choose one or the other by intended behavior first, and that always works out great.

That said, I like the idea.

All those .BAS files were an education.

I did the same in QBasic (and Tandy Color Basic)!

I feel like the old Choose Your Own Adventure books were a sort of precursor to programming for a lot of us. Basic if/then/goto.

For me the spark is reinvigorated. I can try ideas before I didn’t have the time for, prototype and test and only pursue what proves to be worth the time.

Same. This was true for so many of us. An open source education.

There’s a marked difference in quality depending on context, usage of sub-agents, initial specs, and model-wise a big difference from what Opus would produce and Fable.

I’m not saying I’m hand coding, but saying getting good outputs doesn’t take any technique means your definition of good outputs probably isn’t very refined. And saying it hasn’t taken technique for 4 years is just flat wrong.

Funny I made some very similar points awhile back in a blog post, thinking of it in terms of mode collapse: https://tonyalicea.dev/blog/single-mode-burnout/

Thank you! I tried to add just a little snazz without changing the core.

I've made two updates: the wind and round text should be more legible with a slightly transparent background under it. The camera is less whiplash-y and pauses for a moment after the banana hit if it's zoomed out and the zoom in is a bit slower.

I understand, I'm not going for accuracy, just suggestion. For someone like you it won't feel right, I totally get it.

Nope, haven't changed it! I think it's an aesthetic preference thing.

I think the first one for me was The Oregon Trail followed shortly by QBasic Gorillas and Nibbles. It was my first step in coding beyond Turtle Graphics on an Apple from even earlier in childhood.

Opening up the QBasic source code was eye opening for me: that computers weren't the realm of hackers typing incomprehensible text on TV and swapping floppy disks, but something that could start to make sense. My TRS-80 came next, and, for me, the rest was history.

Good memories. I wonder what the memories will be for kids right now in the age of LLMs.

Code-wise, mostly LLM. I gave it the original QBasic source code so that's not mine either.

This experiment was a guidance experiment for me with Fable. Heavy spec and planning architecturally and UX, and strictly no JS frameworks or dependencies.

I do these kind of experiments with new models, and Fable has been the most successful so far for capturing the intended UX and feel per spec.

Yes! Fun things that either you’d never have taken the time to build otherwise, or recreations of things that you know well.

Things where you know how they’re supposed to make you feel (like games from childhood), and getting that experience match is an exercise.

I did let the LLM handle the mouse and touch aiming for v1. That’s an experiment as I prefer typing in the boxes or using arrow keys.

I think it needs tweaking to let you hone in a value better. What are you thinking?

Fair. This is a direct port in some areas of the 1991 game, which strategically was more try something then dial it in. I’ll ponder. It’s almost arcade vs simulation in some ways.

That is, if you can calculate it too easily then the first player always has a huge advantage.