Joe Duncko, who’s an engineering director I’ve known from hackathons and local meetups for a couple of years, recently wrote a piece for his blog: Organizations Adapt to the Cost of Iteration. He argues that:

• Businesses have historically been hesitant to add new software features to their products because of the time investment that’s required to implement them;
• Also, it’s been hard to iterate and improve on features because of the delay that a lengthy implementation process creates between having an idea and getting user feedback on it;
• And now that coding agents make it quicker and easier to write new software, businesses should be more willing to try new ideas, instead of subjecting them to lengthy approval processes.

I think that this makes sense on its own terms, and it’s the kind of change that a lot of people in the software development world are hoping for. But, I don’t know that it’ll always be an easy sell to the people who run companies. I want to take a quick step back, analyze this take from a holistic standpoint, and try to figure out the risk/reward calculation that an organization faces when it strives for higher velocity. I think the basic question is just this: in the future, will organizations move at the pace of software development, or will software development move at the pace of organizations?

The tech sector of the economy has a structurally disproportionate amount of influence over the world. A key reason is that the number of people working in tech stays relatively low even as the number of people that their product reaches skyrockets. Take Discord: they have a few thousand employees and hundreds of millions of users. Contrast this with a business like a grocery store, where the amount of work goes up fairly steadily with the number of customers and the amount of stuff that they buy, or a lawyer’s office, where the amount of money coming in is tied to the amount of billable hours worked by specific attorneys and their staff.

The reason that so many businesses want to invest in AI is the potential of pushing this dynamic even further. A traditional law firm can only take on so many cases before needing to hire more attorneys; in contrast, the theoretical AI equivalent could serve tons of people with a few prompt engineers and the AI agents that they delegate the lawyerin’ to.

Originally posted to LinkedIn.

A few hot takes for the #vibecoding era:

I. Coding has been heading towards higher and higher levels of abstraction for a very, very long time. We’ve gone from assembly language to C to JavaScript.

When I first started pursuing web development, years before the initial release of ChatGPT, people were already talking about it as primarily a process of gluing together existing code, instead of writing things by hand like the good old days.

Nevertheless, interview questions about low-level stuff like sorting algorithms still got asked, even though almost no-one has written such things from scratch outside of school for a long time. I think that this indicates something about the enduring value of being able to understand technical stuff at a high level of detail.

The term “separation of concerns” gives you an easy way to throw a wrench into almost any programming argument. It’s hard to interpret at the best of times, but it definitely sounds weighty and important, and so you can use it to argue against any code that you don’t like and for any code that you do like. Here are some models for separation of concerns that I have seen:

Model A: The Language Model

A one point, in the world of web development, it was easy to tell which part of the code was which, because each concern was addressed by a different language. The HTML created the content, the CSS established the styling, and the JavaScript added the interactivity:

“Promises” are a ubiquitous feature in the JavaScript language. For example, if you call the function fetch in order to get some kind of JSON object from an API, fetch will return a Promise:

const thisIsAPromise = fetch("/api/get-id/1");

What does that mean? The MDN documentation informs us that a Promise “is a proxy for a value not necessarily known when the promise is created.” That’s kind of true, and for a while, I even believed it. However, nowadays, I think that it’s actually easier to think of Promises as a way to manage code, not data.

In my post about GIFs, I pointed out that the creators of the GIF file format explicitly said that it wasn’t meant to be a great format for animations, but since it was widely available in people’s browsers, and no-one actually read that spec, it ended up being used for animations all over the place anyway, and now it’s all the format is known for. By opening a technological window, and allowing some limited animations to be stored in .gif files, they closed a door (new file formats with more advanced compression are constantly pushed back on because people are used to GIFs.)

Unrelatedly, here are two keywords that exist in JavaScript: const and let. let creates a variable that can have a new value assigned to it later, while const creates a variable that will always have the same value attached to it. const is the typical way that people declare variables in modern JavaScript; thanks largely to linting rules and style guides like the Airbnb JavaScript style guide, which for whatever reason was very popular back in the day, a generation of programmers learned that changing the values of variables was to be avoided, and obviously const is the way to do that, right?

Buckle up, everybody. The AI understander has logged on.

Human brains are wired to anticipate and recognize patterns. The quiet thump of footsteps coming up behind you; the sinuous stripes of a tiger’s fur, undulating as it quietly crouches in the bushes with knife, fork, and barbecue sauce clutched in its paws; the halting rhythm of popcorn in the microwave as it finishes up its popping and starts to burn. In particular, there’s something in us that responds to patterns in language. I don’t necessarily mean literary, sophisticated forms of language: I mean that people still put fragments of Radiohead lyrics in their Instagram bios, and that we all grew up enthralled by the three-syllable rhythms of Dr. Seuss.

But what if I told you that writing that kind of thing is now easy?

Well, it’s not quite top-tier Dr. Seuss material, I guess, but that comes down to the prompt, right? I could have told it to write about something more Dr. Seuss-like. Animals, breakfast foods, headwear, that kind of thing. But the fact that it understood the prompt - the fact that it knows who Dr. Seuss is, that it presumably knows what a trisyllabic meter is, that it knows which words rhyme and which don’t - that makes it smart, right?

I’m not so sure? If a human sat down to write a Dr. Seuss-style poem, and produced that result, then we could probably conclude that the human knew those things, or at least had a fundamental intuitive sense of them. But at this point, in year three of their mildly terrifying reign, I’m pretty sure that large language models are mostly good at replicating patterns. That doesn’t mean that they make good decisions about what to replicate or why they’re doing it. But, they feel like they’re smart, partly because they hack the human brain by reproducing patterns that are interesting to us, and partly because they mix the patterns together.

The animated GIF is a new kind of ideogram that computers have added to our lives. (An ideogram is a visual symbol that indicates an idea without corresponding to any specific spoken sounds.) You can convey a vibrant feeling in a brief moment of video, as long as the feeling is along the lines of: Leonardo DiCaprio raising a wine glass. Donald Glover carrying pizzas reaching a room filled with flames. A white guy blinking in idle consternation.

So why is the GIF under attack? Everywhere, platforms and hosting services are trying to replace it with other file formats. “GIFs” on Twitter are MP4 videos, set to be soundless and looping. Imgur introduced the concept of “GifVs,” which are mp4 or WebM videos that are displayed like GIFs, way back in 2014. The framework I’m using to create this blog, Astro, will automatically turn GIFs into WebP files when I deploy the site to production. One of the ground zeroes for the animated GIF phenomenon, Tumblr, has been experimenting with videos-as-GIFs for years, writing extensive, carefully-worded posts to try to introduce the concept without angering their userbase.

And make no mistake - users hate new file formats, like WebP. Statistically, you probably hate .webp files already. Here’s what a brief Google search has to say about them:

So why does this format exist? Why do any file formats exist? Why do I care? Let’s consider the practicalities.

Something I enjoy is when your focus doesn’t have to jump around a whole bunch when using a computer program. One classic example of UI that manages the user’s focus is the humble float label:

Computers are bad at math. If you go into your friendly local Python terminal or JavaScript console, and type “0.1 + 0.1 + 0.1”, it will produce a number that is almost, but not quite 0.3. When you try to write programs that do math, things like this often happen. You may have heard that it’s because the number is “floating point.”

There’s a lot of superstition and folklore around floating-point numbers in computer science, plausibly due to occult-sounding terms like “mantissa” and “significand.” “Floating-point math is imprecise,” people will say. But the “floating-point” part gets way too much emphasis. “Math is too precise” is a better way to put it. The poor floating-point number is just chronically misunderstood.