The difference isn’t just in the content but in the quality of human connection. I’ve found that comic conventions foster a sense of mutual appreciation that feels genuine and unpretentious. People come together not to compete or impress, but to celebrate creativity and shared passions.

I was fortunate enough to sit third row at the Futurama panel, watching the cast interact with each other and the audience. What struck me was how much they seemed to genuinely enjoy being together. They praised the writers for creating such memorable characters, thanked the audience for their dedication, and showed real appreciation for the collaborative process that brings the show to life. There was no hierarchy of importance—just gratitude for being part of something meaningful.

This supportive energy extends throughout the convention floor. At one point, someone asked me to take a photo of them—they were dressed as some character which I didn’t even recognize—posing with another attendee cosplaying as Storm from X-Men. The moment was simple but telling—two strangers connected not by personal history but by appreciation for each other’s creativity. They admired the craftsmanship in each other’s costumes and shared a moment of genuine connection. It wasn’t performative or transactional, just authentic recognition of shared enthusiasm.

I’ve written before about purpose in our increasingly automated world. In my piece:

I explored what remains of human agency when machines remove from us the obligation to “do.” Comic conventions offer a compelling answer: our purpose can be found in creation and connection. In these spaces, people aren’t passive consumers but active participants—making costumes, creating art, building communities around shared stories.

What makes comic conventions beautiful is this rare space where creation is celebrated without pretense, where kindness is the default mode of interaction, and where human connection feels authentic. In a digital landscape often dominated by criticism and division, these physical gatherings demonstrate what interaction could be at its best—supportive, appreciative, and genuinely interested in what others have created.

As I left C2E2, walking past groups taking photos and exchanging contact information, I realized that these conventions represent something essential: spaces where we can set aside cynicism and simply appreciate each other’s passions. They remind us that beneath the digital noise and social posturing, we still fundamentally desire to create and to connect—and when given the right environment, we do both remarkably well.

Originally published on my personal site, stefanoscotto.com. The original version lives here.

The choose your own adventure format has been around for decades. You have these books where they would say “turn to page X if you wanna continue this way and turn to page Y if you want to continue this way.” We have advanced quite a bit at leveraging software to do this but fundamentally what we’re trying to do is enable readers and even creators to create a dynamic story and enable re-readability and promote a deeper engagement with the story and the characters.

You can take the simplistic choose your own adventure stuff like the text-based adventures where you could go left or right or into the forest or into the mountains, and the results are always deterministic and created by the story creator. You can also look at more complex stuff like video games like Detroit: Become Human or Mass Effect where your choices define what types of conversation and story paths you can open up.

There are some choose your own adventure projects out now, where some of the results are generated by the AI itself, so rather than having a deterministic flow of storylines and character arcs the results are determined by previous choices sort of on the fly within the LLM’s context.

This project started out when I read a post about leveraging GenAI for software engineering workflow. I wrote my own post about it:

I wasn’t really sure what I was trying to achieve other than to see how the GenAI tools could help me build something. I’ve gone through this like I said for years in my head, and the complexity can get extreme when you’re dealing with something this potentially dynamic.

I sought out to see how far I could take this with extremely ambitious ideas and then ultimately dialed it back quite a bit. Here’s the story.

Here are the results:

• The Marble Run Adventure - The story

• The Marble Run Adventure - The code

Originally published on my personal site, stefanoscotto.com. The original version lives here.

When I watch “How It’s Made”, I can’t help but think about how all of those jobs that robots are doing now used to be done by people, or by no one at all because they were impossible. The circuit board assembly where robotic arms place hundreds of microscopic components with perfect precision. The metal fabrication systems that cut and weld complex parts with submillimeter accuracy. The injection molding machines that maintain precise pressure while producing thousands of identical components. These machines didn’t eliminate manufacturing jobs—they transformed them.

10-15 years ago, I’d spend entire days implementing complex concurrency patterns in pre-ARC Objective-C, carefully architecting thread-safe singletons and debugging race conditions in Core Data background contexts. Or I’d be fighting with CSS across browsers, spending hours debugging why my flexbox layout worked perfectly in Chrome but completely broke in Safari. Today, AI can surface these solutions in seconds, synthesizing scattered knowledge into coherent fixes.

Perhaps most importantly, all that time investment has historically been a powerful reason not to build at all. How many side projects have been abandoned because the work needed to go from idea to complete product felt too daunting? AI is systematically removing those barriers, letting us jump straight to the interesting parts and enabling creators to focus on their crafts.

Originally published on my personal site, stefanoscotto.com. The original version lives here.

This is one of those simplified explanations that has become ubiquitous, but it misses something fundamental about what’s actually happening inside our devices.

The truth is, computers don’t actually process abstract mathematical digits. What we call “1s and 0s” are really physical states - open and closed circuits, the presence or absence of electrical current. It seems like a logical abstraction to help us conceptualize computing, but we’re really just talking about electricity flowing or not flowing through pathways we’ve designed.

I think about this often while working with software engineers who are many layers removed from these physical realities. We build on abstraction after abstraction, from transistors that can be either “on” or “off”, through machine code, through high-level languages, to the interfaces we interact with daily. Each layer creates more distance from the physical foundation.

My son is already curious about how electicity and magnetism work, so when he asks me how the computer works, I’m not going to sing “it’s all 1s and 0s.” I’ll tell him that inside are billions of tiny switches that can be turned on or off, just like the electrical switches which power the light and the ceiling fan. The pattern of these switches creates everything he sees on the screen.

There’s something tangible about that explanation that the binary abstraction misses. It connects the digital back to the physical world, reminding us that even our most advanced technologies are ultimately physical systems.

Originally published on my personal site, stefanoscotto.com. The original version lives here.

I came across a fascinating post by Harper Reed. I recommend reading it, but for brevity, the TL;DR is that he’s using GenAI to ideate, plan, and execute software engineering workflows.

Traditional software engineering takes time. You need to understand the problem, isolate a solution, create your foundation, iterate, etc. GenAI enables developers to take the manual work out of many of these things to enable folks to be creators, rather than manual laborers.

The analogy that comes to mind is building a car in the early 1900s. Think of your job as being a metalworker, building the body of the car. Your time would be spent forging, banging, curving, bending, and polishing a fender. If you could replace that work with a machine, you could enable not only more efficient production lines, but free up your time to focus on more creative endeavors, like improved design.

I think we’ll all benefit from this, but there have been decades of software builders who have done things entirely manually. The folks who are already builders will benefit from these new automated workflows, but will need to stradde the old and new. Those developers who will most likely benefit the most will be the folks who haven’t yet started building, or are just beginning to love software engineering. They will be able to bake GenAI into their workflows, into their mindset from the beginning of their careers, rather than having to retrofit like the current generation.

Originally published on my personal site, stefanoscotto.com. The original version lives here.

The metaphor here is that of a house being built on a solid foundation. Houses can be complex with architecture, layout flow, plumbing, electric, heating/cooling, etc, however these problems have been solved. Upon a solid foundation, we can build layers which we know, based on experiential evidence (our own and that of other builders), how to add things to get a complete and functional house.

Building on top of an LLM (or other models) as the foundation of product software requires a fundamental shift (from CRUD) paradigms. There is still a client layer, there is still and application layer, but the retrieval layer is no long deterministic. While we can reasonably expect and test (with evals) certain outputs, there is no guarantee that one input will yield the same output every time it is executed. There are ways to specify hyper parameters, temperature, decoded output, etc, but one of the most beautiful features of the AI model is that the output is dynamic.

If we try to conform this metaphor to that of a house, we end up with a real problem. Instead of building a house on top of a solid foundation (e.g., concrete) we are now building on quicksand. There can be no expectation that the foundation of our house will be the same today as it was yesterday, or even in a few seconds.

In order for product developers to account for this, they (we) need to shift the way that we design our software. This reconceptualizatin of product is what is truly interesting about this space. Since the data coming from the machine is nondeterministic, it is reasonable to assume that we should be designing client interfaces that are as dynamic as the output from the foundational layer.

What does this mean? Suppose there are 3 ways to build a UI from the ‘data’ layer output:

1. The server sends some data in a predetermined format that the client already knows how to interpret (e.g., structured JSON). All the client has to do is plug in the fields into it’s UI and display to the user.

2. The server sends some general UI representation of the data (e.g., JSON which delineates the ‘design’ of the UI - such as an ordered list of ‘objects’). The client then has to build a design system which takes this UI description from the server and (somewhat) blindly display to the user.

3. The server sends explicit UI instructions (e.g., HTML, React code, python, etc) and the client effectively just has to render it as is.

The first way has been the preeminent paradigm for decades. The second way has had some usage over the past decade or so, but removes a lot of creativity and software design potential from the client side development. The third way is, most likely, the design to which we are moving.

I don’t expect this shift to be ubiquitous across different software systems, there are many systems which require deterministic input and output. However having tailor made UIs for each client, which are dynamically created by an AI, will require a shift of software engineering design patterns, particularly for the top and bottom layers. The application layer should fundamentally continue to be able to leverage GOF design patterns, but the way that we create and display data will necessitate emergent software design patterns that have yet to be fully understood or realized.

Originally published on my personal site, stefanoscotto.com. The original version lives here.

It resonated with me because during those extremely dark times, where we were isolated from friends and family and society as a whole, we only had each other. As a father and husband, as a human, I was compelled to find my own inner light and share that with my immediate family.

I thought about all of the people throughout history who have endured much worse than we were enduring during our pandemic. I channeled their grief, but more importantly I channeled their strength. If people who suffer always give in, then we have no people. Only through persistence, only through finding purpose can we endure.

My purpose became eminently clear.

In the world where AI (more specifically AGI) is very real, it’s natural to try to forecast the future where we live concurrently with robots. I looked up the origin of the word robot, and I read that it originated from the Slavonic word robota which meant “servitude.”

It seems like a logical step that humans would try to create autonomous robots to not only augment human work, but effectively do the work for us. Anything that we don’t want to do, we’d have a robot do it.

Supposing we could create systems and robots that could do everything that humans don’t want to do, ideally, conceptually, this would give us the freedom to pursue other uses of our time. But the fundamental problem will be that without endurance, without deep purpose, we cannot be free to pursue any intellectual or physical ascendancy.

Our purpose is to be human, and to be human is to do things. All that said, if we are no longer doing things, then what is our purpose?