The Bootstrapped Founder

Arvid: 00:00

AI has made a mark that I don't think we'll ever walk back from. And in this new era of AI assisted coding, our roles as developers is evolving. Hey. I'm Arvid, and welcome to the Bootstrap founder. Just a few years ago, I was a wholly different coder.

Arvid: 00:22

At my best, I was breezing through documentation and writing mostly functional code. I'm still proud of that. It worked most of the time. And at my worst, I'd be chasing typos and strange bugs for hours to no avail. I'd get stuck and I wouldn't have a way to find my solution to any problem.

Arvid: 00:40

And not once would I have thought of using AI to help me. Because back in the day it really didn't exist. But things have changed. We now live in a world where software developers who don't use AI tooling to write code are almost becoming extinct or they're threatening to become extinct. The technology available to us, either extremely cheap or even free, is so ubiquitously useful and impactful that coding as it was 5 or 10 years ago will be completely replaced by something.

Arvid: 01:14

And it will come with a cost. And this shift clearly comes with several advantages in terms of productivity and speed, otherwise people wouldn't talk about it all the time, but it also heightened a lot of fears and exposed potential problems that are I believe worth exploring. So as someone who uses AI tooling to build software products right now, I wanna consider why we're on this trajectory, what risks this is here, and how we can mitigate them. I also kinda wanna explore what it means for people who are just starting to learn how to code and build software products in a world where AI is an expected part of the software development process and what the future might look like. The clear advantage of using AI is very simple.

Arvid: 01:59

At its core, it types faster than you. It generates code faster than a human could ever write. That's really all it is. I mean, there's more, but that's the the central thing. It's faster.

Arvid: 02:09

It's super super fast at coding. Even the most recent non AI code writing tools that exist out there of a certain complexity are much slower and much worse than what even open source AI can currently do. And by AI, I'm really just talking about large language models trained specifically on writing code or being generic enough to have the capacity to write code for the user. JWT, Claude, these public things that are available right now and capable of writing code with some better than others at producing software that actually works. As a software entrepreneur, I personally have to balance my willingness to solve interesting technical challenges with the business necessities around me.

Arvid: 02:53

So anything I can do to write good functioning and reliable code faster, it's just something that I have to explore. And I really have to do it because it might be a benefit, it might be an advantage. So when the first AI coding assistance hit the market like a year and a half, 2 years ago, I quickly looked into them because everybody else was at least in my little Twitter bubble, and I very very quickly noticed the power within. And for an experienced developer like myself, these tools were from the start incredibly useful because they could create code that I could very quickly scan and then approve or reject. And that's the crux here.

Arvid: 03:32

You have to know good code to be able to approve good code or reject bad code, right? You have to know what it is. And there's something about being already experienced in coding that makes these tools very useful. You're effectively outsourcing the process of just writing stuff, writing the logic and all you do is constantly code review. You code review as if you had a junior coder or a senior coder writing stuff for you and you look into it and you say, well, this pull request is something that I want in my code or it's not.

Arvid: 04:04

Everything an AI does is like that pull request for you to review. And this means 2 things. For experienced developers, these tools are massively impactful on the quality of work because they're also faster. And for people learning to code, there's still a necessity to actually be able to understand how coding works at its score to then judge the AI's results effectively. And this is the core problem that I see people voicing over and over again.

Arvid: 04:34

If you're learning to code with AI, you might never truly understand the solutions you need to judge the code against because you need to understand the ingredients and how recipes work before you can cook. Otherwise, you're just destroying food in the process of, like, turning up the heat and maybe throwing it out and putting some spices in there. If you don't know how these things work and how they are kinda applied to a process, well, then you're gonna mess up your food. And I think the same applies to code. Do you understand or you have to understand syntax, grammar, evaluation and execution of code to see both the parts and the whole of what a good piece of software is.

Arvid: 05:14

And there is probably a stage in a developer's journey where writing with AI generated code and tools that generate it is a hindrance to your skill development. Because if you don't know how to code, you cannot imagine what the overall end system will look like or will have to look like. And that's the thing against which you'd have to judge what the auto generated code is and what it does. And this level of experience to be able to judge this up until now took a long time to develop and you had to really go from the absolute basics of assigning variables and doing loops and doing if then else's and understanding complex things like functions, methods, classes, you have to kinda learn your way into it. And now all of a sudden this gets presented to you and you can just say, yeah sure, let's try this.

Arvid: 06:02

And I see a lot of people fear mongering over this particular problem and they're upset, maybe rightly so, that people today don't have to learn how to code anymore to produce somewhat useful results. And the fears here are that people will never get the experience to understand how code works and will then only create mediocre and very likely unmaintainable code and still make money much earlier in their career. A lot of people get very upset about this and it reminds me of this recurring meme, a historically recurring meme about how kids these days don't wanna work anymore. It's a theme that just resurfaces every decade, a kind of self delusional perception that I also see in technology. There's a visual meme going around, a kind of a a JPEG somewhere that I saw I saw a couple of times that shows a newspaper or many newspaper clippings from, like last year going back into the nineties, the eighties, the fifties, the thirties, even the 18 fifties all saying essentially the same thing in the language of that time.

Arvid: 07:00

There's a moral failing in the youth because they don't wanna work anymore. And I find it so funny to think that every single decade, somebody comes up with the idea that back in my day, everybody wanted to work, but nowadays, nobody wants to work anymore. Let's make it about a change in society. And I think this is a very self delusional perception, right, delude yourself into thinking that things are different even though they're not, and it has been repeating for 100 of years. And I think we see a very similar pattern in technology.

Arvid: 07:27

Because looking at the development of programming itself over the last like 60, 7 years, we've seen similar transitions. The first one was from the very basics of computing from punch cards to digital systems and machine language. The second transition was from machine language machine code to compiled languages. And the third one from compiled languages to interpreted languages. That's kinda how I roughly see the switch in technology.

Arvid: 07:56

And each time there's this kind of quantum leap in technology or if it's not tech then it's the way we interface with it, you have a group of traditionalists and purists who believe that the new thing is causing a loss of knowledge and a loss of proximity to the tech. They think it makes people less good at their job because they need to understand less about what coding and programming is about. And every single time these people have been proven wrong. When people went from machine learning to compiled languages, the accessibility of coding went up. It skyrocketed, I think.

Arvid: 08:33

You didn't have to understand what registers are or what a jump not equal event is. You just needed to understand what an if then else is, what's closer to how humans perceive logic and what a variable assignment is. That's all you needed to know and from there you could build code that ran the thing you wanted it to do and you could share it more easily because it was more readable, it was more accessible. And then the same thing happened when you went from compiled to interpreted. The jump from compiled languages to interpreted languages made things like JavaScript in HTML and PHP and Ruby on Rails or even Java much more available to more people.

Arvid: 09:12

You could just put a file somewhere, upload it through FTP if you wanted to, at least that's my experience in the 2000s, and if it's loaded the correct way it will be executed exactly as you want it to be. Maybe even on a completely different system than you wrote it on. You wrote it on a Windows computer, it runs on a Mac. No need to compile, no need to go into the machine basics, to go into the functional very specific things. You just knew that it would be interpreted correctly.

Arvid: 09:40

And this additional step of accessibility led to more interesting and better tools being built around them. And with those tools, solutions were now more quickly architected that put prior systems to shame. And I believe we're at the precipice, if not already in the middle of another such leap. Removing from programming as a means to instruct a computer to generated code. Code created from a prompt.

Arvid: 10:06

It's not a rung up the ladder of abstraction here away from the underlying system. Right? From the machine instructions to something that is a compiled instruction or an instruction to be compiled and then an instruction to be interpreted and now we're just giving an instruction to be it's kind of an interpretation but a different way, right? You you give an instruction to what you want the thing to be like and then you just it's a declarative way of instructing the machine. And recently I experienced this firsthand when I needed to convert a transcript into an srt subtitle file format for PodScan for my business.

Arvid: 10:43

Instead of writing the code myself, I instructed Claude AI to take a stub of what I'd written like 5 lines of here's what the input is, here's what the output is supposed to be, and I'm just iterating over every line and doing some kind of fake version of that. And I told it to create a function that would translate my transcripts into valid SRT data. And the result to coming in within, like, 5 seconds of me, like, just telling Claude to do it was a working function that reliably did the job on the data that I gave it. I told Claude the input for this will be a text like this, post a part of a transcript there that I wanted to translate. And then I said, I want the output to be valid s r t data.

Arvid: 11:25

I hit enter. That was it. And what came out was a working function that very reliably translated all of my transcripts into an SRT file when needed. And I had a moment of clarity there because I really just defined inputs and outputs and maybe some kind of constraint that it had to be, a PHP function somewhere in Laravel, I would use it. I I told it as well.

Arvid: 11:49

But the actual content of the thing, I I didn't care about. I didn't tell it to to write a specific way, a specific algorithm, and I I didn't even tell it which algorithm to use to create valid SRT data. It found that all by itself. And this experience made me realize that coding is evolving. It's no longer about typing out every line of code or even knowing what code to type.

Arvid: 12:14

It's about knowing what needs to be done and then instructing AI to do it. The mental model of the function of taking data, splitting it by line, processing each line to a specific defined standard, that remains crucial, but the implementation of that and the understanding of how exactly it should happen is delegated to the AI. And part of me, the developer in me, still struggles with accepting this change. The fun part used to be parsing the data, spinning the line, taking the timestamp, moving that one line, taking the text, and moving that to the next line, and then putting the index of the whole line there and the whole file into moving it is another file and all of this. But in a way, it really is not the fun part anymore.

Arvid: 12:58

I'm finding fun now in being better at instructing, at prompting. And I would wager that particularly with something like SRT, conversion, every single day on this planet earth, somebody implements this feature in some way. Somebody takes a file, turns it into some other file that is in a well defined format that somebody else has probably written a library for already. And what I realized is that why developers are so well paid and why developers are so needed to build these systems, it's not that we know how to split a file into individual lines and then take individual parts of that and put it into a different line. The fact that I can verbalize what needs to happen, what the inputs are, what the outputs are in the general process that I have a mental capacity to even just say valid SRT is the output that I need and this kind of structured text is the input you will get.

Arvid: 13:51

That is what software development is today and that is what software development will keep being and grow into even more in the future. Gone are the days of chasing every single line and creating bugs all the time because we missed a comma or something here or there. Machines will handle that for us. And honestly if you're a developer right now it's quite likely that your IDE, your coding environment already does a lot of this work for you. So what we're left with and going to be left with in the future is architecture from the big picture stuff like designing a full application with by I don't know 17 different things that all need to work in tandem to the small picture stuff of defining individual functions, maybe defining ways to test them and all of that.

Arvid: 14:33

That's what we're gonna be left with. But the actual implementation that is kind of moving away from us. We're removing the executing part from coding. We're placing prompting and instructing at a much more relevant part of our journey as developers. To prompt and to instruct accurately, we need to still understand mental models of logic process, data structures, and data transformation.

Arvid: 14:57

And perhaps teaching development will have to change here just as it has since the seventies or eighties where people were taught basic and COBOL and c or Ada. Maybe instead of writing code, software developers will be tasked to become instructors. The earlier we understand that to be able to prompt and instruct accurately, we need to understand mental models of logic and process and data structures and data transformation. And the more and the quicker we can establish a curriculum for developers of the future who do not have to dive into every single line of code manually, the better. For the longest time, I felt there really was no difference between being a writer and a software developer.

Arvid: 15:37

Both write text. Either writer writes text and the software developer writes text of an instructive nature. One writes for people, the other writes for machines. Of course, the text varies and the kind of instructiveness varies too, but it it was always the same thing. Like, whenever I wrote a blog post and I wrote some code, it kinda felt like the same thing just for a different audience.

Arvid: 15:57

But now it feels we're moving away from the writing part and we're becoming editors. And I feel that in my writing as well. I it's not that I have AI write my thoughts, but I use a lot of transcription. I use a lot of free form thinking when I write. And then the AI pulls it together into text that I then get to edit.

Arvid: 16:16

And I feel we edit somebody else's thoughts to fit with what we know the audience needs sometimes when, you know, you have an AI create something for you. I think that the same thing happens in coding. You have the AI's version of what that code is supposed to look like, and then you can edit it into what you know it should be. The audience for a book editor is not the writer, but it's the readership of the books that the publisher brings out. So the audience for a software editor can be so called is the systems to computers, the interpretive systems that execute the code created by these AI systems, not necessarily the user.

Arvid: 16:54

So if you wanna write well as a writer and a coder, you need to understand what editing is. And if you wanna code well, you need to understand what prompting and instructing is and how to edit the results of the results of that. It's a it's complicated even to express, but I feel we're moving away, like, strongly away from the creating typing part of coding and much more into like a cerebral thinky part. And it's always been a thinky thing. Right?

Arvid: 17:21

Writing code has always had a lot to do with thinking through structures and thinking from a point a to point b, and now we don't even get to walk the walk. And there will likely be hiccups along the way. Many developers are quite defensive about this change and they feel insulted that something they spend years mastering cannot be done so easily. And a lot of the developers are hyper defensive about this because coding as it is now has taken many people a long time to learn and understand. Right?

Arvid: 17:48

They have committed a substantial amount of resources, maybe decades of their lives to it, and all of a sudden that is not valuable anymore because a machine can train on, like, hundreds of thousands of lines of code within minutes. Something that took you 4 years, a machine can do on a GPU in a couple minutes. Yeah. It's to have it to be easy for code to be generated feels like an insult. It feels like an insult to me and it definitely feels like an insult to some, but the benefits of this, they are undeniable.

Arvid: 18:18

I personally benefit massively from this increased speed of generating code. It's always easier for me to judge code, to to look at it and read it than to come up with it in the first place. That's why coding to me is so fundamentally different now. The the products I'm working on right now are so differently built than the products I built, like, 5 or 10 years ago. It is really bizarre.

Arvid: 18:38

The speed at which we get to not just write code, but parse and understand code and validate it is very different. AI has made a mark that I don't think we'll ever walk back from. And in this new era of AI assisted coding, our roles as developers is evolving. We are becoming architects. We're instructors.

Arvid: 18:56

We're editors of code. We're not just mere typer or writers. And while this transition may be challenging and certainly is for some, I think it opens up so many new possibilities for innovation and efficiency and software development. We cannot look past it. We have to embrace it.

Arvid: 19:12

And as we move forward, we need to embrace this change while also ensuring that we're developing the skills needed to effectively guide and instruct AI in creating the software solutions of tomorrow. And for that, we need to still understand how things are architected. And it's very very important that if you're just starting out to learn how to code, you try to build things by yourself or at least you try to give the AI tools that you already use very specific prompts about very specific parts of the thing you're building. Don't let them build the thing for you and then learn from that. There's a lot of bias in these solutions and LLMs are at their nature just guessing machines.

Arvid: 19:55

So what they guess might work, but it might also not, and you cannot really judge this until you've built something for yourself. But the future of coding is this, you have to live with the AI being part of your journey, and that future is already here. And I think it's a thrilling blend of human creativity and machine efficiency. So we'll have to see where this goes, but be aware that it will not go away. It's way too impactful and effective for experienced people in the field that it will just run its course and be replaced with another hype.

Arvid: 20:30

I don't think so. I think this is gonna stick. The tools that I'm using all find ways to meaningfully integrate AI. All my software development tools, my software observation tools, my software testing tools, all tools find ways, and that's an indicator that AI is not just a buzzword, but actually something that makes a dent in our experience as developers. So, yeah, might as well embrace it.

Arvid: 20:55

And that's it for today. Thank you for listening to the Bootstrap founder. You can find me on Twitter at avidkahl, a r v I d k a h l, and you'll find my books on my Twitter course there too. If you wanna support me and this show, please tell everyone you know about podscan.fm. I highly highly recommend that, and I leave a rating and a review by going to rate this podcast.com/founder.

Arvid: 21:15

It makes a massive difference if you show up there because then the podcast will show up in other people's feeds and any of this will really help the show. Thank you so much for listening. Have a wonderful day and bye bye.