TLDR: I’ve been programming for 25 years, and now I vibe code disposable software for fun in my spare time (and I don’t always look at the code).
Hey, long time no see !
Yesterday I thought that it was a long overdue I write something on my blog, and then I started thinking it would be interesting to write some kind of essay on my programmers’ life, since with AI I’ve been thinking about it a lot.
I have been programming for around 25 years now, and doing it professionally for about 18+.
It feels strange, because in my head I am still sometimes the teenager discovering that a calculator could do much more interesting things than calculate the cosine of an angle, solve equations and draw functions on the screen.
All in all, one of my first programming language was TI-Basic, on a Texas Instruments calculator (I will always love you my dear TI-89 <3).
- During my studies alone I used C, C++, C#, Java, Python, Awk, OCaml, Delphi, Maple, PHP, R, TeX, Bash, SQL.
- Professionally, at various points, I have been paid to write C, C++, Java, Kotlin, Python, Objective-C, Swift, JavaScript, Perl, SQL and Tcl.
- For fun and personal projects there has been Clojure, OCaml, Java, Go, Ruby, Delphi, Elixir, PHP, TI-Basic and C/C++.
It is a ridiculous list when written like that, oh and I also like text editors, from Borland Turbo Pascal, to DevC++, Visual C++, Borland Delphi, Macromedia Dreamweaver, Emacs with tuareg mode when I used OCaml daily, to JEdit for Java and PHP, TextMate, Eclipse, IntelliJ, XCode, Atom, VSCode, Vim, all Vim everywhere I can, I also currently use Zed on my mac (with Vim bindings).
Old screenshots
At one point I was into Delphi and C and started writing my own shell, commands and terminal named FTerm, in order to learn more and have one on Windows.
You can see JEdit, Emacs, Quake3, RavenShield, FTerm, TeamSpeak there are some icons I don’t remember what it was.
I even started writing an OCaml IDE named KmlI, but it was too big of a task, I never finished it.
Partly thanks to DHH and those early Ruby on Rails demo with TextMate, somehow sent me into a completely unnecessary obsession with text editors. Anyone who has spent enough time programming knows that this is a perfectly normal stage of the illness. At some point you stop asking yourself how to write your application and start asking whether the real problem in your life is that your editor is too slow to render, doesn’t have enough motions, shortcuts and plugins.
I have always enjoyed coding, I like understanding how things work, having a problem sitting somewhere in my brain for hours and finding the solution by myself. I like taking something that works badly and making it work well. I like taking something not performant and make it perform faster. I like code that somebody else can understand six months later, systems where the architecture makes sense and where you can move through the code without feeling that each file was created by a different civilization.
And I have a particular dislike for slow software, computers are absurdly fast, even if I know developer time costs more than CPU time, I still hate waiting for software to finish what needs to be done, and it is very common. I find that there is even something super offensive about clicking a button and watching a spinner for too long (too long depends on your taste) while the expected task is finishing its work.
So performance has always been part of the pleasure for me too. Not premature optimisation everywhere, but at least caring about it and knowing roughly what the machine is doing and what you are asking from it.
I loved being involved in programming challenges, like Advent of Code, leetcode, code jam, I solved useless little problems simply because they were interesting and/or because I was bored, or I just wanted to learn, or I just wanted to see where I could rank in the global leaderboard.
And also, I always had side projects.
Before they were called side projects
At the time, you just made stuff, it was not indie hacking, building in public (I never do that anyway). You made stuff because you wanted it, or you needed it, or your friends wanted/needed it, and also because you were bored and wanted some fun.
On the TI-89, I wrote things mostly for myself and for school friends. Mainly little programs whose output was exactly what our teacher wanted to read, with some variables replaced with the correct answers. Then I discovered a program named Variatio or maybe it was my brother that shown me. This program would do the same and then even more.
I didn’t even knew there was a community on the web sharing TI-89 full softwares, games, it was crazy. I was just a kid with a calculator with amazing programming capabilities I had no idea of. I already knew about a programming language named C, I did see some code sample but I was a total noob, I rented a book at the library, started learning it, and discovered Ti-GCC, this is where I started going deeper, I played games like TiCave and FallDown, I spent HOURS playing them. And also where I discovered I could look at the source code, also Othello 2 which was super great (I never won in difficult mode). I digress but all that to explain how I discovered some kind of open source software, and that these people and softwares where way out of my skills, so I needed to catch up, not really needed, I wanted to.
Later I spent a lot of my spare time playing games online, especially Quake III Rocket Arena and Rainbow Six: Raven Shield. We had chans, TeamSpeak, clan websites and forums, even dedicated servers, creating all kinds of little problems that absolutely required custom software !
So naturally I wrote custom software, I made little Delphi utilities like a quick multi-user game-settings switcher for Raven Shield (creating .ini files on the fly before the game starts); tools to find friends in gaming rooms so that you can know where they are and join them, display the status of our TeamSpeak at all times on our website (this was PHP), an Alt-Tab utility for Quake III on Windows. Various things that made sense to maybe twenty people on Earth, but those twenty people included me, we liked it very much.
Pictures from my very first projects
GC GUI: a GUI frontend for Great Code by Christophe Beaudet
MPE: a picture editor in Delphi
RvS KB: a key binding editor for Raven Shield in Delphi (yes, when I was not playing with my clan, I was named pr¡ñtƒ)
RvS LSS: a live server stat GUI for Raven Shield in Delphi
I even created something close to a ClanBase (a major competitive gaming platform) for French gaming community on Raven Shield. Before esports became arenas, sponsors, professional coaches and teenagers earning more money than senior software architects, we had clan wars organised on websites by people doing PHP after school.
I forked the phpBB templating system and built my own tournament and leaderboard system around it. Clans could play against other clans, results were registered, rankings updated, tournaments managed, I do not have the code anymore, but I remember functions more than 200 lines of code, if and else you could not count, the wtf moment when I discovered the $$ in PHP. The architecture was not perfect, probably there were tons of security holes, but it worked, I was happy, people were happy. And that was enough for me.
There was something very satisfying in seeing software you created being used by a community you were part of, it was obviously not monetised I did not earned nothing except thanks from friends on the web.
The speed of my spare time
The limiting factor on my personal projects has always been time. At a certain point in time when I had enough skills, I could build almost anything I reasonably wanted (except full games or very low level stuff like OSes and drivers of course, I never had the necessary skills), given enough time.
A personal project had exactly the speed that my available evenings and weekends allowed. Meaning when I was young and living at my mum’s I had plenty, and I used it to learn and learn, build and build, tinker and tinker, sometimes until very late. I remember when creating a small photoshop in Delphi at university, I did spent the whole night and did not sleep at all, but I was very proud to have implemented multiple kind of blurs (gaussian, radial, …).
But when your daily work gets more serious, and you have more responsibilities, a family and kids, well you have less of that time, which is absolutely normal. My personal software development gets then compressed into whatever spaces remain, but I never stopped having ideas here and there, just I couldn’t finish them. Like everybody else I have probably around 30 to 50 repos I started over the time that are simply dead. This is where AI changed something much more important for me than autocomplete, it changed the economics of my spare time.
When the machine got really good
I have used coding assistants for I would say 3 years now, at first they were interesting and then became useful, even surprisingly useful in the end.
Turns out somewhere around the end of 2024, or maybe during 2025 depending on the type of work, something changed. Until then I still considered myself a better programmer than GPT. Of course, it knew more APIs than me, or some syntax I forgot when switching language. They could produce boilerplate instantly, but I felt that when things became serious, involving architecture, subtle bug and performance issue, I still had the advantage. I believe this was true, at least, but now I am less sure.
Better programmer is a nearly meaningless measurement anyway. And if you put me inside a Java codebase I have known for ten years, and you give me a weird production bug involving concurrency, historical business requirements and three previous migrations nobody documented properly, I still have huge advantages because context and experience matters. But give a recent model a well defined new project today and compare what it can produce in an hour with what I can produce in an hour, and there is simply no comparison.
It thinks faster, types faster, it also knows Go, Kotlin, Java, Swift, SQL, CSS, JavaScript and twenty libraries at the same time. It can write tests, refactor, investigate, do migrations, read documentation like I would but 1000 times faster, cross check, switch from frontend to backend to database without the kind of context switching problems I would have. Also and most important for me (and a lot of developers), it never gets bored. I do get bored, there are parts of programming I love, and there are also parts I do not love at all.
Like, updating plumbing code, writing ten almost identical tests, glue code, moving data between representations, some are parts of being a CRUD monkey. Big migrations, like moving a project from Spring Boot 3.x to 4.x, is sometimes hell, you go into all kind of subtle problems you do not want to deal with (Hibernate issues, Jackson upgrade, …).
The AI has no concept of oh no, not this shit again. (at list until now), it will just do it, and if it gets something wrong because I’m not the best prompt engineer and my SKILLS.md are not up to date, I will try to tell it why, and it does it again. Sometimes it will require several iterations before I will consider the code decent enough, and sometimes I am amazed in how it pinpointed exactly what I wanted from only 3 to 4 lines of prompt in not perfect english (I don’t know why I 90% of the time talk to AI in English while it perfectly deals with French, it even speaks better French than me, lol).
This leaves me with two contradictory feelings, one is I feel incredibly empowered, and two, I also feel a little diminished, maybe slightly dispossessed also. Because, in the past when I built something, I could say: I made this. Not only I had the idea, but I knew every class, every function, all the dirty tricks and workaround, because my own little fingers wrote all these lines of code.
Today I can still say I made the application, but the meaning is different, I just described it, wrote an AGENTS.md (or made Claude/Codex write it based on a vague prompt), corrected some decisions. I did not actually wrote the code. It is maybe the software development equivalent of being a carpenter who spent his life making furniture by hand and suddenly receives a machine where he can describe a chair and watch it manufacture one.
The carpenter can make twenty times more chairs, which is very useful, but I can imagine that after a while he starts thinking about what part of the chair still belongs to him.
Vibe coding with 25 years of baggage
I looked on the internet who was the first coming with the vibe coding expression. Apparently it’s Andrej Karpathy, and later described it as Software 3.0, where natural language itself becomes a programming interface.
I suppose what I am doing now with my personal projects qualifies as vibe coding. In the beginning of it it was vibe coding with 25 years of code reviews experience, where I reviewed everything the AI would generate, every file, function, tests. Nowadays I stopped reading all of it, I currently have some personal vibe coded Go software which I did not inspect even one line of code. I still read enough of it because I am interested, but that is a pleasure driven by my aim to learn, it’s not necessary for these kind of projects.
I am not talking of vibe coding professional production systems (yet) where there are consequences, colleagues and customers, the risk model there is different. I mean personal projects, now I mostly look at the architecture, ask how the project is structured, inspect the important pieces, lookup the data model. I also challenge choices, ask why it selected one approach rather than another (if it doesn’t tell me right from the start, which it does sometimes). I care about the interfaces, that it is easily extensible right from the start, then once built I run it and test behaviors, ask it to write some bench to be sure I am satisfied, and that is all.
I don’t have the same skill level in every language. I am extremely comfortable with Java and Kotlin, for example. I know Go reasonably well, I understand the philosophy, I can read and write it, but I am not the Go programmer that I am a Java or Kotlin programmer, so I cannot compete with the machine in all these areas at the same time.
So I simply trust what the AI is doing, it is not blind trust, more like informed trust. I know enough to understand the shape of the solution and I know enough to ask the right questions. But this is why as to be able to keep an informed trust I currently only ask AI to generate code in languages I know and understand.
I have no skill in Rust, I have no skill in Assembly nor in Haskell, so I would not create any personal project using AI with these. Even if I don’t always read the generated code, I still can if needed to. One exception being CSS though, I am absolutely terrible at it, I don’t like it and I don’t want to read it even one line, I just want the website to look OK!
I have never produced so much personal software
The funny consequence is that after years of having less and less time available for personal programming, I am suddenly more prolific than ever. If I need something, I look around, and if it doesn’t exist or if it’s not like I imagined it would be, then fine I will just make it.
Some things can be an afternoon project, or from a weekend to a week or two. When I am super obsessed with a new idea, I alternate between Claude and Codex, they can totally be best friends. It’s funny how if I tell GPT about an idea and ask how much time do you think it takes, and will tell me 2 to 3 months, I’m like come on bro and we do it in 2 days anyway.
Recently this produced several tools I needed.
- reliure, written in Go, which connects to my Kindle, transfers EPUBs and handles statistics around my reading.
- pomtool, also in Go, a fast analyser/linter for
pom.xmlfiles. - Bonum, a personal-finance tracking application written in Kotlin and Postgres. This one is interesting because it is one I started before I used LLMs and it helped me spot issues with my schemas, write better and performant SQL code and add new features quickly.
- facteur, a Go command-line tool intended to replace Postman for the way I personally use it.
- An English-practice web application I made for my daughter, using Go and HTMX. It has flashcards, complete courses, exercises and some light gamification (with little cute svg tigers entirely generated by Opus).
- Various python scripts to get my data from withings and graph it the way I want or analyze opendata stuff
And I already have more ideas, none of these have to become businesses, I share on Github for if somebody finds them useful. If 3 people use it that is great, and if no one cares I do not care also, because I am using it.
The cost of making software has become low enough, at least in terms of my own time, that will enough people use this? is no longer a prerequisite before starting. I can make extremely specific software, even a software for only one problem or for 4 people, for my family. Software for me.
I find it very similar to the early web, where people made small websites because they could, and now we can make small applications super quickly because we just can. I certainly created a lot of small websites on different subjects in the past.
I somehow became a Go vibe developer since I stopped writing code
Another funny thing, I have recently started using Go for almost every side project (I like Go anyway).
It is fast, the compiler is very fast, the tooling is excellent, deployment is wonderful because it is boring, you get one binary, voila. The standard library is good, which is cool because the AI doesn’t always needs tons of dependencies, the ecosystem is mature, concurrency is pleasant, and, it is possible to optimize things quite far when necessary.
Also, for my current way of vibe working, AI models are very competent with Go (I find especially GPT 5.5 and onwards superb at it). The funny part is that if I had to write all the code myself, I might have chosen another language, because Go is not the language in which I personally find typing code the most … pleasurable.
There are languages I find more expressive, I absolutely love Clojure, OCaml is wonderful, Kotlin is expressive, Ruby can be shaped like art. But the equation changes when I am not the main code generator anymore. I do not need to optimize for which syntax do I most enjoy writing?, I can just optimize for the properties I want in the resulting software, which are: fast compilation, dead simple deployment, very good performance. And Go is very attractive in these matters.
Programming languages were interfaces between human minds and machines, now if a significant part of the code is produced by another machine, probably the ideal language will not be the language humans would have designed for themselves. Maybe boring languages win, the one with excellent compilers, good static guarantees and simple tooling are becoming super attractive because agents can generate the verbose bits without complaining.
Maybe in the future we won’t even have code to review even if we want, I did read some interview of Elon saying:
« Code itself will go away in favor of just making the binary directly. The next step after that is direct, real-time pixel generation by the neural net. »
« Source code is on the verge of becoming like assembly. The next step is getting rid of “source code” entirely and just making an efficient binary directly with AI. »
That would be ironic, for years we built more expressive languages so that humans could type less, and now the machines is doing the typing anyway.
Disposable software
All this leads to an expression I keep coming back to: disposable software.
We are entering an era where we create software, use it for some time, and throw it away, but I am not convinced this is a bad thing. Programmers tend to become emotionally attached to software, especially early in their careers, I certainly did.
You spend months creating something, you make architectural decisions, fix bugs, fight for it in meetings, make it shine, it becomes your application, like a digital baby. Then some reorganization happens, a different branch of the company buys a product that covers 70% of what your application does, or management changes, two departments merge, a strategic programme appears with a PowerPoint containing several arrows and the word synergy. You go back to your desk, and your app dies.
When I was a junior this bothered me a lot, all that work and code, all my beautiful abstractions, to the trash. But in the end, it does not mean the work was wasted, the software had value while it was useful, and I certainly did learn a lot in the process.
A bridge is not considered a failure because it is replaced after 100 years, a restaurant meal is not a failure because you don’t keep it forever, software has developed this kind of mythology where permanence is supposed to prove the value of it. Winamp was great, it’s not because someone uses Spotify that Winamp was not a useful piece of software that made history, even if I prefered foobar2000 over Winamp, but the case is still the same, Winamp was still great.
At work I still do my best to create maintainable software, I still care about quality, performance and the next developer who will inherit it. But I am no longer emotionally disturbed by the possibility that one day somebody says, We don’t need this anymore.. It’s fine, there are plenty other things to build, I am not my code, I just happen to write some … well now I even ask some code to be written for me.
Small open source
A huge amount of the software I have used over the years exists because somebody else had the same annoying little problem before me. You search GitHub, find a repository with 600 stars which does 80% of what you need. You open an issue or maybe you send a pull request. Now suppose I need a small CLI utility today, I can spend thirty minutes searching GitHub and comparing projects, checking whether they are maintained, or I can describe exactly what I want to an agent and have a first version 15 minutes later.
I already did the second, because that is convenient for me, but it creates an interesting problem, in that if everybody starts generating their own tiny version of everything, perhaps we contribute less to shared tools. Instead of one good library used by 50,000 developers, we could end up with 50,000 slightly different generated implementations sitting inside private repositories.
Even considering the advantages of having shared implementations regarding bug fixes, security issues, etc. A generated personal tool does not automatically receive any of those benefits. I don’t care if my EPUB transfer utility survives for twenty years and if it breaks after some Kindle update, I can ask the agent to fix it. But the same attitude does not scale to everything, we do not want 1,000 competing generated implementations of TLS or crypto libraries.
Do not forget also the other sides of maintainers drawn into hundreds of generated pull requests from people who did not read the code and cannot explain what their patch does. I never had to face this because I never had to maintain a very successful project anyway. Some months ago, I happened to write a very small Obsidian plugin that did a very tiny thing which I really really needed for my second brain, and I thought it would be super quick to have it approved, turns out it took multiple weeks, almost 3 months, because the maintainers had thousands of pull requests to handle, this is gigantic work for them, and probably most of it is not only code generated by AI, yet.
I hope open source remains culturally important, I learned A LOT by reading code written by people much better than me, if the future of developers becomes mostly generate this for me, we will lose something, reading good code teaches taste, but maybe what we need will be taste for what good software looks like (architectural, behavior, perf).
Software literacy will matter even more
Knowledge is valuable, that it is important to know all the basics, but I suspect another form of literacy will become more important if AI generated software becomes the common, we can call it software literacy.
It is knowing what software can reasonably do, when something sounds simple but hides difficult edge cases, understanding that data has to live somewhere, that authentication and authorization are different things, what is roughly an API, that if an app needs to sync between devices you have to deal with state and conflicts somewhere.
This kind of knowledge is less about syntax and more about mental models, people who understand software can give an AI better instructions because they know what questions matter, they can also recognize when the result is suspicious.
Imagine two people asking an AI to build a personal finance application. One says, Make me an app to track my money, the other says I want local-first storage, imports from CSV, immutable transaction history, categories that can be renamed without modifying past raw imports, no floating-point arithmetic for money, and I need to be able to export everything in a documented format.
The second person has not written a line of code either, but they understand software, and today that difference produces very different results. I believe my experience gives me that advantage because I spent 25 years accumulating these assumptions, and when an agent proposes something, I already have a model in my head of where it can go wrong.
How much of this will remain necessary once models become better at asking the questions themselves ? A future coding agent could answer make me an app to track my money by interviewing the user for twenty minutes before generating anything. Asking about multiple currencies, editable transactions, reconciliation, what happens when an import is performed multiple times, privacy settings.
At that point, the system will compensate for the user’s lack of software literacy, but even then I think understanding software will remain useful in the same way that understanding finance is useful even if you have an accountant. Delegation works better when you can understand the consequences of the decisions which are made for you, and when something goes wrong, somebody needs to know what wrong means (I want this person to be me).
What exactly is a developer then?
This is clearly a question I don’t know how to answer, what will a software developer do five or ten years from now? We have heard the comfortable answer for several years: AI will not replace developers. Developers using AI will replace developers who don’t.
Maybe it’s true. But as explained earlier, today my experience still gives me an edge when using coding agents, knowing when to split a project, un-necessary abstraction, and all that, but I see no reason to assume this edge is permanent. Today’s model needs me to say, No, don’t structure the project like this because it will become painful when we add X, the one in three years will already know that, it will know it better than me. It will have been trained on 10 million similar projects, maybe it will simulate multiple architectures at once, generate the prototypes and benchmark it while I an still trying to explain my prompt and reasoning.
Every time another layer can be automatized, the remaining human role moves a bit, perhaps that will continue for a long time and humans stay at the top of it, but perhaps not. Anthropic CEO said that in 3-6 months (so very soon, now) AI will be writing 90% of the code software developers were in charge of, and then he clarified that writing 90% of the lines is very different from removing 90% of software engineers, which is an important distinction.
I can imagine several futures for software developers, and what makes all of this complicated is that some completely opposite scenarios both seem plausible to me.
The optimistic one is that we simply create much more software.
This is already exactly what happened to me personally. AI did not make me spend one tenth of the time programming and then use all the remaining time watching Netflix, I still use roughly the amount of spare time I can reasonably dedicate to personal projects (even more, in fact), but in that same amount of time I can produce many more things. Instead of one project slowly progressing for six months, I can have several things working after a few weekends.
There is no reason companies could not behave similarly. Imagine a company has 100 developers and AI somehow makes each developer five times more productive, we could obviously say that the company now only needs 20 developers, and I am sure some companies will absolutely do this.
But the other possibility is that they discover they have enough work for the 100 developers anyway.
In every company I have worked for there was always much more software people wanted than developers available to build it. There are features sitting in backlogs for years, little internal applications nobody has time to create, manual processes everyone agrees are stupid but that are still there, spreadsheets everywhere. There must be millions of these small problems inside companies, all the classic shadow IT.
Software development has always been expensive enough that many problems were simply not worth solving, but not with AI. So maybe we don’t end up with less software development at all, we end up with a gigantic amount of software, including lots of things that today would never justify a development.
And this matches the disposable software idea, because not every one of these applications needs to become a product maintained for twenty years. A department can create something for a process which exists for 18 months, uses it, then the process changes and the application disappears, which is completely acceptable if building it originally took a day or a week.
Do a future like this sounds quite good for developers ?
I am still having a lot of fun with all this
I am having more fun doing personal software development than I have had in years.
My main problem for maybe the last ten years was never a lack of ideas, it was that I did not have enough time anymore to transform most of these ideas into working software. AI changed that equation enough that I can now build things again.
The English application I made for my daughter is a good example. Before all this, I could perfectly have built the application myself, there is nothing technically extraordinary about it, but between backend, frontend, exercises, users, some gamification, UI, deployment and all the little details that appear once you start, it could easily have become one of the repos where I worked enthusiastically for two months before slowly abandoning it.
And if she uses it for one school year and then never opens it again, that is absolutely fine.
At the same time, I still want to program and work for myself sometimes, and I think this distinction has become much clearer in my mind recently. If I do Advent of Code, asking Claude for the solution would obviously make no sense because the objective is not to obtain the output, the objective is to solve the problem myself.
When I work on a little algorithm because I find the problem interesting, I want to program. When I need a tool because something annoys me and I want the tool to exist tonight, I want software.
Can AI turn us into entrepreneurs?
With such a small cost of testing ideas, I start thinking a little bit more about whether some of these ideas could become actual products.
I have never considered myself an entrepreneur, I like technology, programming, creating things and solving technical problems, but I never had this reflex some people seem to have where every little utility immediately becomes how can I turn this into $10k MRR?. I am not super excited by marketing, funnels, SEO, customer acquisition and everything that comes after the technical part.
There was also a simple practical reason I did not really try, creating a serious product alone is a huge amount of work. Even when the idea is dead simple, you needed all the glue and basic features around it, auth, emails, payments, monitoring, backups, admin panel.
Maybe there will be lots of people like me, people who were never entrepreneurs before because the cost of experimenting was simply too high, but who know some niche problem extremely well and can now build a reasonable solution by themselves. At least I have ideas for this.
While I have no idea what my professional job will look like in five or 10 years, maybe I will still spend most of my time looking at Java with a much more capable assistant, maybe I will only supervize multiple agents and barely write code myself, software developer will become such a broad term that it will no longer describe much.
Or maybe the entire AI bubble will somehow explode and we all go back to doing things the old way with local models. Or I find a super great idea, execute it with my AI friends in a month and become super rich. Who knows.
Until next time!