back
171 comments
If I have learnt one thing working in software engineering, specifically on AI-enabled products empowering junior engineers, and using Copilot professionally, it’s that you need even more experience to detect the subtleties in the lack of the models understanding of your domain, your specific intent. If you don’t know exactly what you’re after, and use the LLM as a sparring partner to bounce your ideas off, you’re in for a lot of pain.

Depending on the way you phrase questions, ChatGPT will gleefully suggest you a wrong approach, just because it’s so intent on satisfying your whim instead of saying No when it would be appropriate.

And in addition to that, you don’t learn by figuring out a new concept. If you already have a feeling of the code you would write anyway, and only treat the model as a smart autocomplete, that doesn’t matter. But for an apprentice, or a layperson, that will keep code as scary and unpredictable as before. I don’t think that should be the answer.

> you don’t learn by figuring out a new concept

This.

If LLMs were actually some magical thing that could write my code for me, I wouldn't use them for exactly this reason. Using them would prevent me from learning new skills and would actively encourage my existing skillset to degrade.

The thing that keeps me valuable in this industry is that I am always improving, always learning new skills. Anything that discourages that smells like career (and personal) poison to me.

This is not really a new problem, the previous version being "idk, I copy pasted it from stack overflow." True expertise realized that the answer often lay buried in sub-comments and the top voted answer is not often the correct one. LLM's naturally do not realize any of this.
The new generation of devs are going to be barefoot and pregnant and kept in the kitchen, building on top of technologies that they do not understand, powered by companies they do not control.
> ChatGPT will gleefully suggest you a wrong approach, just because it’s so intent on satisfying your whim instead of saying No when it would be appropriate

Therein lies the mistake. Too many people assume ChatGPT (and similar LLMs) are capable of reasoning. It's not. It is simply just giving you what is likely the 'correct' answer based on some sort of pattern.

It doesn't know what's wrong, so it's not aware it's giving you an inappropriate answer.

Years back, I don't know 15 - 17 years ago, I got hired as a .Net developer. I worked with people a lot smarter than me, and some who just didn't really knew what the hell they where doing. But everyone is nice and help each other. One day a less experience colleague is asking whole bunch of small trivial questions, one after another, for the duration of the day. Me and another co-worker, busy with our own stuff, answer the questions as quickly and succinctly as possible. At the end of the afternoon the guy finally ask if we could look at his code, because he can't really make it work. Every question he had asked was a small building block to whatever he was working on, but now he was stuck because in his context he was asking the wrong questions and every time something wasn't working he'd just attempt to slap on more code. There was no design, no rational plan for how this was even suppose to work.

In this case we took our colleague to a whiteboard, and helped him do an actual design and helped him ask the right questions. LLMs won't question what you're doing, they will happily answer all your questions and help you pile on line after line of broken logic.

> just because it’s so intent on satisfying your whim instead of saying No

This really, really, really needs to be fixed. It's probably the most irritating (and potentially risky) part of the whole ecosystem. Nothing more infuriating than being give code that not only doesn't work, but upon the most casual inspection, couldn't possibly work -- especially when it's done it four or five times in a row, each time assuring you that this time the code is gonna work. Pinky swear!

Partly disagree, actually. The current web technologies are somewhat unnecessarily complicated. Most people just need basic CRUD and a useable front end for their daily tasks.
> only treat the model as a smart autocomplete, that doesn’t matter

This is the only way I like to use it. Also in some cases for refactoring instead of sitting there for an hour hand crafting a subtle re-write, it can show me a diff (JetBrains AI is fantastic for my personal projects).

Of course you're right about today's LLMs, but the author imagines a not-too-unlikely incremental improvement on them unlocking an entirely new surface area of solutions.

I really enjoyed the notion of barefoot developers, local first solutions, and the desire to wrest control over our our digital lives from the financialists.

I find these ideas compelling, even though I'm politically anti-communist.

The presentation was also quite lovely.

>Depending on the way you phrase questions, ChatGPT will gleefully suggest you a wrong approach, just because it’s so intent on satisfying your whim instead of saying No when it would be appropriate.

Which is easily solved by using another agent that is told to be critical and find all flaws in the suggested approach.

Sounds great, but this won't work out to the way the author imagines it. We have a very strong bias towards anything technical, but if you've ever worked outside the SWE field, you'll see that half of the people simply aren't interested in "thinking". They don't like or enjoy their jobs. They sure as hell aren't going to sit there and think, "how do I take this problem and break it down into a dozen/hundreds of small steps to create a small app that solves my problem?"

The majority of people are content with learning the bare minimum needed to get by and never having to learn anything new. Don't believe, the proof is self evident the moment you try to update a UI that requires users to do things differently than before.

And this is all fine, I've accepted it by now. It's the way it's always been and always will be. Still, these new tools will empower a relatively small percentage of the population to create amazing open source apps that will be used by a lot of people. The tools also very much empower pro-developers to build a lot more apps with less efforts than before, which I'm looking forward to.

A tangential nitpick: Scientists, Engineers who are not of the Software persuasion, Accountants, and Lawyers, to name just a few, also make up people who work "outside the SWE field". Almost all of these people are interested in thinking; a few of them will probably not be, just as one finds a few people working in the SWE field being reluctant to think. There is a very good reason why people -- even technically minded people -- have trouble with changing UIs, and it is not about them not wanting to think. Consider that the UI could be part of a workflow that is more of a side annoyance than their main job, and that they would rather conserve their mental bandwidth for problems that are more important to them. A doctor shouldn't have to get used to a new timesheet UI just because a designer woke up one fine morning with a new thought.
I do not think it is reluctance of thinking when pianists would complain about Steinway changing the order of piano keys every few years, because a new Steinway engineer thinks his order is better.
> outside the SWE field, you'll see that half of the people simply aren't interested in "thinking"

Whereas inside it's closer to 90% :/

> outside of the SWE field... half of the people simply aren't interested in "thinking"

This is probably true of SWEs as well (although in some places it's hard to get away without thinking at least a bit.)

I think you’re right that the majority of people do not want to learn, but in my experience there are a large number of engineers were who fit into that category, just as there are pockets of other professions that are willing to learn explore and improve. But
> Don't believe, the proof is self evident the moment you try to update a UI that requires users to do things differently than before.

Is this because they don't like learning something new, or because they've been burned so many times by badly done redesigns that make things harder to use for pretty much everyone? I'm sure half of Hacker News despises how Windows has been redesigned from Vista onwards, or at the very least since 11.

Perhaps many people don't like change as much because a lot of changes come less from user needs/insight into what would actually improve the program and more from the need to give designers something to do (or provide another way to add ads/track users/appeal to shareholders).

Having an interest in making your own job easier/more efficient is very different from being interested in accepting every redesign under the sun.

This bleak-ass sorry outlook & the fixed ness on looking at the bleaker parts of it, to me, isn't actually about the sad bleak people. Its about the sorry ass conditions & technosocialcultural bankrupcy that let so many people down, that didn't give them good hooks to start digging in & try enjoying their own powers. It's also about being overwhelmed and emotionally unserwater by unrewarding crappy rentier-capitalism.

The belief system of humanity in itself needs nutrients, needs to seed and grow positively people. Open source is by far one of the strongest currents about for that.

Right now open source is a mess & bogglingly complicated. Technology in general has gotten vastly less accessible year after year, the on-ramps to understanding detoured into ever more appliance-ized experiences & neofuedal cloud empires happening in other people's computers. Far fewer are primed for the esoterics of software, know the basics, or have positive rewarding experiences tinkering and tweaking. Humanity has been shoved into superficial & coopted/dishonest experiences. Heck yes, a lot of things are against the possibility of the good.

But we unlike almost all other relationships with the material world, we can directly improve things, can keep enhancing things practically without material constraint, limited chiefly by imagination & will (ML excepted I guess). We can grow the pot, open up computing & it's softer side progressively, create better on ramps & more learnable, observable, experience able authentic experiences.

Over time I hope the barriers to being interested might be less severe. The other material conditions dragging people down & shutting them off from engagement might persist. But I think there can be a very tangible source of hope here, a demonstration that people, when they are doing their thing, creating as they might, when they are empowered, are cool. Are good. Are a role model. And that - with hope - will keep us iterating & improving, will hopefully lead to more efforts to keep redefining & expanding general purpose computing & soft systems in less deeply technical terms.

I have a really strong reaction against projecting the users of today & their sorry chained-to-the-cave-wall state to what people might be if there were some honest shakes out there. Open source is far from a perfect liberator today, 100%, but this is part of the journey, is part of why we need to be practicing & trying, so we can create & iterate towards alive interesting systems that welcome people in.

Unpopular opinion inbound: what will spark a barefoot developer revolution is not LLM auto-coding, its making spreadsheet software more easily extendable and FUN.

By extendable, I mean doing things like generating and sending emails, and using plugins to integrate with external services. By fun, I mean non-enterprisey, something that one would WANT to engage in as a hobby and that a total novice can pick up and gradually learn. Something you can engage in with friends.

I know that there are things that meet the extendable part of the equation, its the fun hobby part that I don't think has been cracked yet.

I think a big part of why I became a coder is because I enjoyed playing with Microsoft Access as a kid - but I'm a weird nerd, so I don't think that'll cut it for others.

I largely agree with you. Spreadsheets are arguably the most successful no-code/low-code tool out there in that they've enabled millions of people to automate some task or complex process and effectively become programmers, despite the fact that I personally find an empty spreadsheet to be kind of intimidating to look at.

I think the only point of disagreement we might have is that I don't necessarily think that the speadsheet, even an improved one, is the best graphical model/structure for articulating complex processes, but it seems to be the best we've discovered thus far.

Personally i'd rather we bridge the gap between using excel and writing python with something that is between the two, rather than relying on LLMs.

Call me a skeptic, but i remain very unconvinced that LLMs will be the enabling tool that lets non programmers program.

This is my dream to. It goes something like this:

- Find any cool tool online, download it, use it locally. Your data is persisted to your own local machine and your own personal cloud.

- Visit any website, download it as your own, modify it. Host it as your own and continue to add to it online.

- Browser vendors implement user accounts & hosting into the browser, so anyone can make a working app locally with a little bit of HTML and serve it to the whole internet with the press of a button.

- If your app takes off and goes viral, part of the economic value provided flows back to you through micropayments.

Basically: portable HTML "objects" that can be treated as mutable apps instead of only static documents = like GitHub + Codepen + Vercel + NoCode in one neat little package.

The author makes it sound like most software in the world is software that is made to scale. I strongly doubt that. I would say that at least ~50% of software is ad-hoc scripts or specialized tools for single organizations.

It is no wonder that the software that is used by a large number of people is talked about more than software that is only used by a handful. Home-Cooked Software already exists, it is just not as easy to see.

AI/ML is going to absolutely destroy the first generations of junior developers. They won’t get enough practice doing software development by themselves and won’t know enough to fix subtle bugs introduced by the code. It’s like using a graphing calculator in high school. Probably perfectly OK for a smart kid taking calc his senior year, but would absolutely be used as a crutch by struggling or lazy students in a pre-algebra class.

Right now AI is mostly controlled by mega corps abusing copyright laws because they can get away with it. I seriously doubt this is going to drastically change.

Basically, I don’t understand this authors cute, homely portrayal of AI.

People just don't care and won't do it if it requires more than a fleeting thought to get it done. Excel is comically powerful and only a tiny fraction of users have any interest in tapping into that. Every step of the way, for the last 50 years, pretty much all parties involved have actively worked to move away from end-user programming.

Words can't describe how happy I would be if that wasn't the case, but it's better to walk than curse the road. Changing this would require pretty much everybody on the planet to re-evaluate how they interact with a computer, and I'm not holding out on that.

I love ~everything about this. I've been doing software engineering as a career since the late 90's and think she's spot-on about both the local-first movement and "barefoot developers". @stevekrouse, thanks for posting -- and @maggieappleton, please keep doing what you do!
I wish people gushing on ML code generation would familiarize themselves with SW development history bit more. For example the introduction of SEQUEL (predecessor of SQL) paper is worth reading, its just few pages: https://web.archive.org/web/20070926212100/http://www.almade...

Key quote:

> Much of the success of the computer industry depends on developing a class of users other than trained computer specialists

I believe COBOL had similar aspirations to be language for non-professional developers. One of the first high-level languages were called autocodes because they automated code generation. Sound familiar?

The difference between compiler and ML model is not that great from high level. Both take human-readable(/writable) input and produce machine-executable code in the end.

Huge amounts of SW engineering has been already automated and delegated. Consider how much effort setting up a CRUD application would be if you were writing machine code on bare metal system compared to writing high-level language and leveraging stuff like Linux and PostgreSQL.

It isn't even that high of a barrier for entry though? If someone really wants a piece of software that does something, there's probably already some python library for it. calling some imported python function isn't hard

if someone is too lazy to find some python library to import, but driven enough to come up with an unambiguous way of telling a model to do something in natural language, that's a borderline non-existent demographic

really it's kind of baffling to me, some people just hear "code" and think we're talking about some undecipherable thing like the Voynich manuscript. makes me feel like the guy out of the Zen and Motorcycle maintenance book who was confused why his friend refused to figure out how to fix his own bike. some people just refuse to learn. if they wanted to, they would have already

> They [barefoot developers] are the kinds of people who would be thrilled to have more agency and power over computers.

I don't think this is true. No-code software development solutions have existed for a while now and we have not seen a rapid increase in software being built.

Technical people who are non-programmers are not interested in having power over computers at all. They want to get their work done. And if doing this work requires too much work, they'll give up on the task than learn the thing.

Sandstorm? https://hn.algolia.com/?dateRange=all&query=sandstorm&sort=b...

an open source platform for self-hosting web apps

Not a single mention of Open Source Software. The author is missing a huge piece of the puzzle.
Great talk, more for the new-developer than the cynical seasoned pro but I love the direction.
Analysis seems flawed to me.

They claim that large companies can never support the long tail since it’s too expensive to produce those features.

But they also claim that cost of software production is going to fall dramatically such that people can build their own apps for small user-bases.

I don’t mean to sound negative, since I love the picture painted by Local First, but I don’t think it will work out that way.

Back in the day (1970s-1980s), every computer came with BASIC or something preinstalled -- often in ROM. Growing up I thought computers were for programming as bikes were for riding or pencils were for writing with. Using someone else's program was always an option, but you always had the full capability of the machine ready to put to your own uses, and an easy way to get started.

We forwent this in favor of getting that consoomer dollar. We gave the user ever more elaborate premade applications, which is nice; meanwhile, programming environments went from the default mode of interaction with the machine to expensive add-ins (thinking of early Windows with Visual Basic and ToolBook). HyperCard was free on the Mac, but didn't keep pace with the machine's expanding capabilities. QBasic was perfect for the DOS environment, but it didn't really transition to Windows except as Visual Basic, which again was an expensive add-on. Speaking of, even the RAD tools of yesteryear are largely gone. We have open-source dev environments now, but they aren't approachable the way microcomputer BASIC was. Getting someone set up with Node or even Rails requires command-line jiggery-pokery and installing all sorts of dependencies, just to get started.

And now, we're somehow hoping that a somewhat cleverer Dissociated Press is going to bring back citizen programmers? Fuck no. If we want end users to program their own apps, we have to find our way out of the shit we created, not add new layers of shit to deal with the old layers. The pathway to citizen programmers is making programming accessible, with full capabilities available, with documentation, right from the jump. No toy languages (e.g. Small Basic). Kids should be able to write turtle-drawing programs with the same language/environment adults use to build real-world applications.

With all due respect to the author, I take umbrage with the statement "They never end up in the terminal, because that is a huge jump in complexity, usability, and frustration from using something like Airtable or Notion."

Using the command line isn't more complex, it's differently complex. It's differently complex and writ large, schools make no effort to teach it.

I wonder if LLMs is the new low-code.

A promise that is never going to work.

The way I would support local-first databases is to promote Sqlite db files as the replacement for CSV files, and so everytime you see CSV file support, ask customer service to ask their tech team about when they will support the Sqlite db export format.
I don't know. My personal take is that low-code/no-code tools should have ushered in an era of homemade software, but it didn't. It's something I think about a lot, incidentally. We've had the technology to make software using a GUI rather than a text editor for a very long time, and yet programmers still use text editors, and programming in general hasn't really been all that democratized. At best, it's now possible to create a website without knowing how to code, but it usually isn't a particularly good one.

A simple explanation is that the devil is in the details when it comes to implementation. Edge cases and granular behavior are hard to capture except in granular snippets of code. I'm not convinced that LLMs necessarily solve this problem. Even if you are working with a theoretically quite competent LLM, there are still going to be instances where describing what you want is actually challenging, to the point where it would be easier if you just did it yourself. You could argue that this doesn't matter in the case of simple software, but I think we underestimate what people really expect out of something that's "simple", and I think we underestimate people's tendency to grow bored of old toys, especially if they don't work as expected.

If anything, my belief is that LLMs by themselves aren't necessarily going to make this a reality. You need an accessible and empowering UX/UI to go along with it. Otherwise, asking an LLM to build software for you probably won't be much of a fun experience aside from those who are AI enthusiasts foremost.

Side note, I have painful feelings about so many UX researchers I used to admire jumping on board the AI hype train so uncritically. I kind of get it, their job is to speculate on new possibilities a tech offers without getting too hung up on external complications. Still, I feel disillusioned. It seems that prior to all of this these same people were questioning our implicit assumptions with how we interact with computers in really interesting ways (in the same vein as Bret Victor). Now, their takes are starting to converge with that of the usual anonymous midwit AI enthusiast on Twitter who pivoted from crypto.

Put more bluntly, the idea that LLMs will usher in a golden age of people making simple software is kind of a boring speculative future, a speculative future shared and talked about by the most uninspired and boring people on Twitter.

There is a lot of reason to be excited about local-first and how it could enable much lower costs to build useful apps (both in terms of money and skills). AI will certainly spur that on.

But I think local-first will be of the biggest benefit to small teams of professional developers who can see local opportunities bigger corporations are missing. At least in the short term.

There are barefoot developers too, but it's not as simple as professional vs barefoot — there's a spectrum of app developers, each with their own economic rationale.

Really interesting article. It feels a little like what I heard about VisualBasic and REBOL back in the day. AI definitely helps, but I'm still not convinced it will be able to create anything but really simple apps. Likely it will facilitate those people who are maxing out tools like Excel even further.

As well as being a professional developer, I also do these local first types of apps, so I expect once the AI tools become good enough, we will be the first to figure out how to use them.

Just use OSS that already is there and contribute to it and we have it covered - no need for „everyone becoming a developer” and there are tons of local first OSS tools.

Where contributing is using OSS, commenting on it, sharing work done with OSS tools with others, filling in bug requests and maybe even paying something for it.

Working with tools and sharing work done with tools is important because everyone is using photoshop instead of Gimp, everyone is using Excel instead of libre office.

"I'm not saying everything Mao did was great"

Understatement of the (20th) century!

Some interesting ideas. But it seems to make out that nearly all professional software is developed by mega corporations in California. But there are lots of small software companies, open source developers and hobbyists developing a vast range of apps for different niches. More would be good, though.

The blog layout is truly fascinating
kinda disappointing comments in this thread. Thanks to LLMs I have built more home cooked software than ever.

I’m not an engineer, but I've written more code this year than ever. LLMs have helped me tackle a huge backlog of projects at home that I wouldn't have been able to justify starting before. And I know 3-5 others doing similarly (we have a group chat).

Off the top of my head, this year I’ve made:

- webscrapers

- notification agents

- websites

- data manipulation and charting

- IaC devops for my entire homelab

- an RPG (well, a roguelike)

- applets for OBS

- chrome extensions to glue together a bunch of stuff I do to study Japanese

I’ve written projects in languages I’ve never used like rust and elixir, and learned a ton. Am I gonna switch ladders to be a SWE? Nope, but for better or worse have stopped asking my SWE friends for help.

And lately, between RAG and large context models, it’s much easier to improve existing projects. Typing, refactoring, linting, documentation generation, and GitHub ops are now practically effortless.

I like this article, I just don't think it will work in capitalism world.

I could be wrong.