Agent Skills Will Replace Side Projects in Portfolios

I've often heard people, from my teachers to other developers, say that side projects are a good way to stand out in a stack of resumes, sell yourself during an interview, and prove your competence without having to say it.

I still believe that. In fact, I would go further and say that side projects are one of the most convincing ways to demonstrate what you can do. But the landscape is changing. Since the rise of AI and LLMs, platforms like Lovable and v0 have made it possible for many more people to turn an idea into a working project.

Of course, not everyone will build. But more people will, increasing competitive pressure and making differentiation harder.

That does not make projects worthless. It makes them less scarce. A project will still show what you built, but it may no longer be enough to show how you think, make decisions, and take responsibility for the result.

We are developers, not merely builders. Building software requires engineering, and it is far more difficult than it seems. For example, my dad is experimenting with vibe coding, but without my help choosing the tools, understanding the architecture, and selecting the platform, it would be nearly impossible for him to create projects that live up to his ambitions.

I love seeing my dad vibe-coding on Cloudflare with Antigravity, and I never expected to see that. But this fun story also carries a lesson: we have to raise the bar and broaden our mindset. What we used to call a side project can now be created with a few prompts, and a startup idea can now become a side project. Our ambitions have to be bigger, but so does the evidence we provide of our engineering ability. That is where differentiation will come from.

Just do things honestly. You'll still be way ahead of most people, more than you think.

You’re Not Alone Anymore ​

Until recently, building software meant relying on your own hands and time. You had to dedicate days and nights to learning the tools, choosing the architecture, and writing the code. Now, you can be a few prompts away from a working project.

With agents, you can spend more time on the things that matter: understanding the problem, thinking about the architecture and useful features, writing content, and checking the result. The agent can handle more of the production work.

You're not alone anymore. You have a partner, a teammate, to whom you can delegate part of the work. Please, delegate wisely. Delegate the keyboard, not the thinking.

For a while, we heard that AI was a bubble, that it was hype that would soon be over. Individual products may come and go, but the underlying capabilities are not going away. With the release of Qwen3.8 27B, we can now run powerful LLMs on consumer-grade hardware. Sure, it is slow, the hardware is expensive, and it is not at the level of frontier models. But ChatGPT was released in November 2022, and look where we are now.

LLMs and agents are here to stay. We, as a market, have to adapt, evolve, and broaden our mindset. As I explain in my MiXiT talk, the developer's job is changing rather than disappearing. Companies will have to adapt their hiring processes, and candidates will have to adapt their portfolios.

Until recently, a technical test often looked like this: "Here is the problem. Explain how you would solve it, then write the code." With agents, writing code as the sole evaluation criterion becomes less relevant. A stronger assessment could evaluate how a candidate takes an agent from an idea to a working product, or from an existing product to a new feature, in both greenfield and brownfield contexts. The candidate would still need to explain the decisions, review the output, and remain responsible for the result.

This has huge implications for how we prepare as candidates. We need to understand what an AGENTS.md file is and what an agent skill is, but also how to write and evaluate them. We need to recognize, just by reading them, what is good, what is bad, and what could fail. We need to improve our prompt and context engineering.

This does not mean that the fundamentals are becoming irrelevant. Quite the opposite: the less code we write ourselves, the more we need the knowledge and judgment required to evaluate what an agent produces. Architecture, databases, networking, security, testing, and maintainability still matter. So do critical thinking, curiosity, and the ability to act.

When I use the word skills in this article, I am talking about two related but distinct things. First, there are human skills: engineering fundamentals, judgment, critical thinking, prompt engineering, context engineering, and the ability to guide and review agents. Second, there are reusable agent skills: documented instructions, resources, and workflows that we give to agents so they can perform a task consistently.

The second kind is the new portfolio artifact I want to focus on. Reusable agent skills do not replace human skills, and they do not replace projects. They sit alongside them. Projects show what you built while agent skills can show how you work and what you have learned to make reusable.

We could go even further by publishing ready-to-use assets that help others start faster.

Show Skills Alongside Projects ​

If you don't have a domain yet, buy one. For real.

A website is the best storefront. For years, we have used websites to showcase our professional experience, side projects, and open-source contributions. Now, we can also use them to publish the skills we have created for our agents.

These skills are not a replacement for projects. They are a new kind of artifact that can sit alongside them, and a new way to differentiate yourself from everyone else.

Agent skills are meant to be reused across projects, easily installed, and easily discovered. So we need a way to expose them on our websites.

That's why Cloudflare published the RFC Agent Skills Discovery via Well-Known URIs. The idea is to standardize how skills are exposed on a website, so anyone can discover them and use them in their own projects. A central index will be available at https://<your-site>/.well-known/agent-skills/index.json and will list all the skills available on your website. By following each entry, people will be able to access the skill and its corresponding files.

Today, tools like skills allow you to add skills from a website to your project. For example, to add my skills to your project, you just have to run npx skills add https://soubiran.dev. In the future, when participating in a technical test, you may import skills to help your agent work as expected, or discuss those skills with the interviewer. This could become one more way to evaluate a candidate.

When you hire a plumber, you don't provide them with a wrench, a screwdriver, and a drill. They come with their own tools. Developers will increasingly bring their own reusable tools and ways of working too. A portfolio will show not only what they have built, but also how they approach building it.

That's my take on the future of hiring and candidate portfolios. I may be wrong about the details, but things are going to change, and we will have to adapt.

If reusable skills are going to become portfolio artifacts, they need to be easy to publish, discover, and reuse. That brings me to the practical part of this article.

Make Your Skills Available to the World ​

The RFC is promising, but does it mean that we have to manually create and maintain a well-known agent skills file? Honestly, that would be cumbersome. Nobody wants that.

So I built a Nuxt module that automatically bundles the skills stored in your project's root-level skills directory into your site, along with the well-known agent skills file at .well-known/agent-skills/index.json.

There is no configuration to write. Just install the module and it will do the job for you.

pnpm install -D nuxt-skills

Then, add the module to your Nuxt config:

export default defineNuxtConfig({
  modules: [
    'nuxt-skills',
  ],
})

That's it. The Nuxt module takes care of the rest.

Your visitors can then use npx skills add https://<your-site> to add your skills to their projects. You could be one of these visitors. To add my skills to a project, I use npx skills add https://soubiran.dev. Easy to remember, simple to use, and it just works.

Maybe you don't use Nuxt. No problem: I also built a Vite plugin.

First, install the plugin:

pnpm install -D unplugin-skills

Then, add the plugin to your Vite config:

import skills from 'unplugin-skills/vite'
import { defineConfig } from 'vite'

export default defineConfig({
  plugins: [
    skills(),
  ],
})

Without any additional configuration, the plugin automatically bundles skills available at the root of the project into your site with the well-known agent skills file (.well-known/agent-skills/index.json).

Building on the Docus Team's Work ​

This work would not have been possible without the incredibly talented Docus team. On 31 March 2026, Hugo opened a pull request to add support for the well-known discovery of agent skills. They added it as a module to the Docus layer.

This pull request inspired my work. At first, I needed a Vite plugin to bundle my skills into my site. Then, I realized that creating a Nuxt module anyone could use would not be too difficult if I reused the Vite plugin's core logic. So I did it, and now you can use it too.

• Vite plugin: unplugin-skills
• Nuxt module: nuxt-skills

That's the power of open source. Thank you, Hugo, for inspiring me.