You Do Not Need Packages Anymore (Mostly)
Packages are no longer necessary in the age of AI-generated code
In the age of AI-generated code, packages are becoming less and less necessary.
Let me start with an example from my own experience.
I wanted to have automatic deployment of my home server, which I can just trigger with a simple command. I used the Terraform Proxmox provider for that, but I had to put passwords somewhere.
Yes, there are tools for that like Vault or AWS Secrets Manager, but I wanted something simple, that I can run locally and is not tied to any specific cloud provider.
Most of them need some setup or are not flexible enough to work with different services and APIs.
Here is where AI tools come in. I was able to create a custom key management tool in Golang that can store my keys safely, is extensible to new services and APIs, and can be run anywhere.
It is not something I would not be able to handle myself, but it is much faster to get it done with AI assistance. The issue came when I wanted to use it in my Terraform configuration, because there is no package for that.
I had to write a custom provider for Terraform that can read the keys from my tool and inject them into the configuration. With AI tools, it was not a problem at all. I just had to give it access to current tutorials how to write Terraform providers and context, and it delivered a working provider in minutes.
Do you need packages?
This is just one example, but it illustrates a broader point.
In the past, we relied on packages to abstract away complexity and provide reusable code. However, with AI tools, we can generate code on the fly that is tailored to our specific needs and requirements.
Couple of arguments why packages are becoming less necessary:
1. The effort to create small specific package has decreased significantly
The AI lowered the barrier to create our custom implementation. Even if the implementation requires more complex behavior, it is still faster to get it done with AI assistance than to find a package that fits our needs, learn how to use it, and integrate it into our project.
You do not need package for simple extensions or integrations, because you can just generate the code for that.
This is just for demonstration purposes, but it illustrates the point.
2. Packages contain more than you need
Even if you find a package that fits your needs, it often contains more than you need, which can lead to bloat and security vulnerabilities. With AI tools, you can generate code that is tailored to your specific needs and requirements, without any unnecessary code.
Less code means less attack surface and less maintenance. You do not need to worry about updates, deprecations, or compatibility issues with packages, because you are in control of the code.
Most of the time, you just need to update your primary framework, update the code that is relevant to your use case, and you are good to go. You do not need to worry about the rest of the package, because you are not using it.
3. Packages can become outdated
Every time you use a package, you are at the mercy of its maintainers. If they stop maintaining it, or if they do not update it to keep up with changes in the ecosystem, you can end up with a broken or insecure codebase.
What applies to the generated code
It does not mean, you should just generate code for everything, but it means that you have the option to generate code for specific use cases, without relying on packages.
You always have to:
- Evaluate the trade-offs between using a package and generating code.
- Consider the complexity of the task and the potential benefits of using a package versus generating code.
- Consider the long-term maintenance of the code and the potential risks of using a package versus generating code.
- Consider the security implications of using a package versus generating code.
Please, always read the code if you plan to ship it. Even if it is generated, you are still responsible for it. You need to review it, test it, and ensure that it meets your requirements.
I still use packages
Some packages are still complex and provide a lot of value, so I still use them.
Most probably, you are not going to stop using numpy, pandas, matplotlib, or Tanstack Query, because they provide a lot of value and it is not worth the effort to generate code for that.
If there is battle tested package that provides a lot of value, it is probably better to use it than to generate code for that.
But for smaller, more specific use cases like manipulation with APIs, custom integrations, or simple extensions, I find it much faster and more efficient to generate code.
Frameworks
If we go up with the complexity, it takes more effort to generate code for that, but it is still possible. I would probably not aim to replace React or Terraform, but I can easily generate code for specific use cases within those frameworks, without relying on packages.
If you have 20000$ to spend, you can generate even compiler for Linux as Anthropic did, but is it something you would want to do? Probably not, but it is possible. Here is a link to the article about it.
Conclusion
packages are not dead, but they are becoming less necessary. With AI tools, we can generate code on the fly that is tailored to our specific needs and requirements, without relying on packages.
Before, you pick package, you have to evaluate tradeoffs.
How I think, when I am picking the package, you can read it in my article about: Do You Really Need That Package?.
Socials
Thanks for reading this article!
For more content like this, follow me here or on X or LinkedIn.
