Saying that AI is everywhere would be an understatement. No one week passes by without a new game changing product is released, or an existing product gets even better.
In this series of articles, I want to explore how I interact with AI. I will see how this technology is currently affecting some aspects of my life and how it could change my future.
I have no special expertise in this field, and I’ll share my opinion on the technologies as an outsider. The objective is to share my observations on the subject and not to bring a technical expertise.
In my first article about AI, I will explore how it is impacting my work as a frontend engineer. In the following article, I’ll touch about content creation and my blog.
Feel free to subscribe to the newsletter if you don’t want to miss upcoming articles.
My experience with AI
I’ve been developing for quite some time now. It all started about 15 years ago when I learned to do C and assembly when becoming an electronic technician.
At the time, I would never have guessed that I would do programming as my work, let alone how the way we write code would change.
To be fair, I wasn’t exposed to AI until recently. As it’s the case for a lot of people.
A previous work experience was my only contact with AI. I worked on an application that generated pitch ideas that can assist onboarding. This was before the release of GPT-3. It was interesting, but I didn’t feel threatened or really impressed by the results. Sure, it was able to generate great text, but it was not applicable to my day-to-day work.
Things started to change with the beta release of Copilot. Seeing people on YouTube having their code automagically completed felt a bit off at first. It was odd to see a software understanding how the streamer wanted to write another software.
It stayed as something I kept looking at without thinking that I would benefit from it. Besides, I didn’t want to pay for this.
All changed recently when I was doing some peer programming with a coworker that was using Copilot at work. My company allows the usage of AI tools for developers working on open-source software, so my coworker was in its own rights.
Seeing my colleague pressing the tab key while generating code from thin air was quite an experience. The AI was working inside a project I knew. That’s when I decided to give the AI a go.
So that’s where I’m at right now. I used GitHub Copilot for about one month now, and I’m planning on subscribing to it. The current state of the tool is quite satisfying, but now as game changing as I was expecting.
My experience with GitHub Copilot
One month of experience is not sufficient to have a full picture, but I feel confident enough to have some insightful information to share.
As I said before, I’m quite happy with how Copilot work, but my experience is as jaw dropping as I was expecting. Copilot feels like a great assistant, an intern that can lay some foundation, but not the coworker I was expecting.
To be fair, I think that my expectations were a bit high. I was hoping to be able to name a method and having it generated in seconds. This is not how Copilot work, even less in a huge codebase.
There are cases where Copilot can and will suggest large chunks of the code, but it’s for methods that are quite simple, helpers for good example. It works even better if you’re working with simple types and not objects.
In my experience, Copilot will work best if you properly describe what you’re expecting (which seems fair) and is quite sensitive to small typos and such. The following video shows how a simple typo will generate a working code but completely different.
I said before that my overall experience with Copilot was good. Let’s discuss the good and where the tool helps me the most.
Using the term intern to define Copilot is a bit harsh. For me the product name is perfect, Copilot feels like, … well, a copilot. It’s not here to steal the light or replace you, but it will provide insightful information when needed.
You can still crash in a wall, but you’re in control. Blindly following copilot instructions won’t make you the fastest, and the same can be said about using Copilot.
Most of the time, Copilot is good at reducing key presses and automating simple piece of codes. For example, writing props, creating
useState, creating conditional styling, … All those tasks are greatly speed up.
GitHub Copilot feels a bit like a dynamic set of snippets that will adapt depending on the context you’re in.
It won’t transform you into a rock star developer, but rather reduce the small annoyances that comes when writing code. That’s plenty sufficient for me, and I’m happy to pay a subscription for that.
The upcoming release of Copilot X is promising and is definitely something I’m eager to try.
However, I don’t really bite into the hyped marketing they are doing, sure it will be great and better than its current iteration, but one of their example is on how to center a div… Not as groundbreaking as the website make it look like.
Where Things Are Going
The GPT4 unveils event gave a glimpse into what the future of AI could be. At first, I was quite impressed with the demo where ChatGPT was able to convert an image into a working website. It felt strange.
However, with time, I realized that their demonstration, while impressive, was not going to replace any developers.
I cannot understand of technically challenging it is to convert an image into code. This is a truly amazing accomplishment done by the OpenAI team. But we don’t need a web developer to do this kind of website. It’s prototyping at best and a gimmick at worst.
This is their first release so it could be expected to see something more impressive sooner than we think. One thing to keep in mind is that the current state of AI is as bad as they have ever been and things will only go crazier from now on.
It’s hard to tell how much this field will be impacted by AI in the next decade. However, I can share my two cent on how AI will impact this field for small and large codebases and for support since they are the 3 areas that will be impacted the most.
Smaller projects are, in my opinion, the one that could benefit (or suffer depending on whom you ask) the most of the development of AI tools.
Those kinds of projects are also the one that could be replaced (to some extent) by no-code tools such as Webflow and the whole range of tools that gravitates around such as Wized, Integromat or Airtable.
The low complexity of those projects makes it possible for AI to provide valuable code generation and either replace part of the workforce or allow them to get more value per dollar.
Besides that, POCs (Proof Of Concept) could be promptly done, which allows for faster hypothesis validation and faster product development iterations.
Large projects/companies’ applications
On the other side of the spectrum, we have company applications and large projects. I don’t have a proper definition on how big that software are, but they aren’t your typical side project.
We can think that those projects have several teams working on them and complex CI/CD pipelines. Besides that, those applications are either seeing a huge traffic or are built for a very specific use case.
In that context, it will be harder for AI to replace developers. Making sure that the generated code respect the business requirements, the code guideline, is properly tested and is looking as intended is going to take some effort.
Those projects have so much interconnected that adding a feature requires many file changes and a good knowledge of the architecture of the software.
Finally, some industries will simply ban the use of AI code generation tools. I have a hard time imagining a developer working on the banking solution connecting his/her code to the open internet. Things could change if the speed benefits are too good to pass, but I doubt it will be done in the near future.
Working on more complex web applications could still benefit from AI, there is some tedious and repetitive work that could be automated. This would allow developers to spend more time architecting the codebase.
Support and Maintenance
GPT-4 can take way more token as input compared to its previous version. This can benefit learning, more on that later but also support and maintenance of software.
I can see tools that automatically update dependencies and make sure that the code is using up-to-date’s standard and methods. Dependencies changes could be made on the repo in a separate branch and be approved by someone from the team.
Some updates introduce breaking changes or optimizations that need to be adopted by developers. An AI tool could fetch the changes from the documentation, look on the repo where this could be applied, make the change, eventually adapt the tests, and create a merge request.
Keeping a large production application updated is a tedious task. Using the latest versions of dependencies is one thing, bug using the latest standards is another. React introduced Suspense with React 18 and things are going to change even further with React Server Components.
An AI tool could make those bug changes easier and automate some of those changes. I doubt that adopting React Suspense would be one click away any time soon, but some groundwork could be done in the near future.
I can also see that some tools will help with bug detection or performance improvements. Having the code scanned (in a CI pipeline, for example) could help with the detection of potential bugs. Imaging a world where potential bugs are automatically reported to a project management tools with links to the code and potential fixes.
Subscribe to the newsletter to get new articles right in your inbox!Subscribe to the newsletter
What about learning?
Learning and training is one last point that could be changed thanks to AI. However. I think that online educators are not going to be replaced by a good prompt, either.
Creating high-quality courses is hard, things are moving fast, and making sure that the course is both up-to-date and accurate is easier said than done.
New context size allows for much larger inputs. This means that users could enter kick-start guides of a library and get up to speed in a matter of minutes. Besides, services could (or have already) make the whole process of learning about a new technology easier.
Although I can see that things are going to change when it comes to education, I’m not sure that the change will be as impactful as some might say. AI models are predicting text to output something that is coherent, they are excellent at that. However, coherent doesn’t mean true.
And that’s where I can see the limitation of all an AI-generated learning platform. Sure it might get things right and will become better with time but relying only on this to learn won’t be sufficient.
Educators will still have a place to provide courses, since they are able to correct their mistakes and fact-check things. Their work could be made easier with AI tools, allowing them to either create more or keep things fresh.
Do I feel threatened by that
I recently spend about one month working on a large feature? This changed impacted all the different products we develop (Mail, Drive, and Calendar) and resulted in more than 80 file changes and 2000 of lines added.
This allowed me to learn a lot about our codebase and involved a lot of people (on both the frontend, the backend, the product and the QA).
Some business requirements were quite insane, and we were able to find about 200 different testing scenarios. It was quite an achievement to have this developed all that in such a short amount of time.
In that context, I don’t feel threatened by AI at all. The number of things to define to obtain the same result as what was done would be insane and will definitely require more work than having a developer doing it.
Imagine having to write down every prop, every UI change, every endpoint to reach, how the UI should behave when an error occurs, when the user doesn’t have the proper permission, … This would be impossible to without having someone touching the point at some point. Finally, how would this code be maintained? What will it look like in one year when a new condition needs to be added?
This is why I don’t feel threatened. Developers are basically translators, we take business requirements or design and translate them to code. As long as developers will write code in less time and fewer characters than using an AI tool would, there is no worry to have.
Besides, as said before, the code is rarely done to be used only once. In that regard, having product managers throwing new features with AI tools is the perfect recipe for disaster. Imaging what the code would look like in a few months, let alone years!
Let’s wrap up
In this first article, I went through some of my thoughts when it comes to the impact of AI on the development world.
As you can tell, I don’t really bite into the FUD around AI replacing developers any time soon. However, I still think that AI will (and is already) changing how software is built.
Some of the biggest losers are the smaller projects, the one that are low-complexity. Those kinds of projects have always been the one to be the most threatened. In the past, WordPress replaced a lot of people with an easy-to-use management console. More recently, the advent of no code made it possible for even more people to build websites with some level of interactivity.
For those projects, AI could have a huge impact. I can see a future where generating a landing page with some interactivity can be quickly done and with little to no code at all.
For now I see that more complex application are going to see how AI impacts developers from the comfort of the tribunes. Depending on their industries, they might be able to get a taste of the change thanks to better seats, but they won’t be anywhere close to the game.
High complexity applications are, by definition, complex. This means that generating code that work on all the different use cases will be impossible or required more time and work than having a developer doing it.
In my opinion, developers, are the big winners of the changes that will occur. It will become easier than ever to level up skills with some AI-supported (I insist on the supported) learning material. This will help new developers get better and get support when something is not working right.
Besides, some repetitive and tedious tasks could be somewhat automated. Declaring props, creating state, building small helpers functions could all be done automatically, freeing time on more complex area of the code.
Finally, some tools could even help software maintenance by adopting the code to use latest and greatest methods, detecting bugs and proposing performance improvements.
Things are looking great for developers
To no surprise, I feel like being a developer is only going to be better, tools will make our life easier, and we’ll be able to make better code.
I want to thank the amazing Josh W. Comeau who recently shared his own opinion (in this article) on the subject and was the inspiration for this article. I can only recommend his content (I think that you must already know him), it’s high-quality and sets a very high bar when it comes to technical blogs.
In the future, I’m going to explore how I feel about AI changes when it comes to content creators. As a small blog owner, I can see some changes in that field and I want to discuss those changes. Spoiler, I think that content creation will also benefit from AI, but not in the way you might think!