How to Learn Agentic Coding at Zero Cost

In my previous post, I explored some of the reasons why getting started with agentic coding can be surprisingly difficult. There are technical questions, changes to the way we work, trust issues, and a learning path that isn't particularly clear yet. But one blocker kept appearing behind many of the others: cost.

Learning requires experimentation, and experimentation means doing things inefficiently before we know how to do them efficiently. That's not a problem when I'm learning a new Java library on my computer. I can write terrible code, delete everything, start again, spend an entire evening going in the wrong direction, and my bank account doesn't care.

Learning agentic coding with paid AI services can be different. While I'm figuring out prompts, context, models, tools, and everything else I don't understand yet, I'm also consuming the same limited resources that I'm trying to learn how to use efficiently.

That made me wonder if I was starting from the wrong place.

Instead of asking "Which AI coding service should I pay for?", I decided to ask a much simpler question:

What can I learn with what I already have?

Looking at the computer in front of me

My development machine is a Mac with an Apple M2 processor and 16 GB of memory. It's certainly not an AI server, and I didn't buy it with the intention of running Large Language Models (LLMs) locally. It's simply the computer I already use every day for software development.

So I started there.

Could this machine run a local language model? If it could, could that model be connected to some kind of coding agent? And if that worked, how much of the agentic coding workflow could I actually learn without sending requests to a paid AI provider?

Notice that the question isn't:

Can my Mac compete with the cloud?

It can't, and expecting it to would make the experiment pointless from the beginning. Cloud AI providers have access to hardware, models, and infrastructure that my laptop obviously doesn't have.

I'm interested in a different comparison:

Is my existing computer good enough to become a learning environment?

That's a much lower bar, but potentially a much more useful one.

I don't need a free replacement. I need a sandbox.

The distinction matters because my goal isn't to prove that we don't need commercial AI services. If I eventually find that a paid model makes me significantly more productive, paying for it may be completely reasonable.

But paying while I'm still trying to understand the basics feels different.

Think about learning to drive. You probably don't want your first experience behind the wheel to happen in the middle of downtown traffic while a taxi meter is running. You want an empty parking lot where you can stall the car, turn too sharply, misunderstand something, try again, and slowly become comfortable with the controls.

That's what I want from a local environment.

A sandbox.

I want to be able to use a bad prompt and see what happens. Give the model the wrong information. Give it too much information. Restart everything. Try another model. Break the setup. Fix it. Ask something stupid. Repeat the same task ten times if that's what it takes to understand why it behaves differently.

If each of those attempts costs effectively nothing beyond using the computer I already own, failure becomes cheap.

And cheap failure is extremely useful when learning.

But what exactly am I trying to learn?

This is where I realized that installing a local model and asking it to write some Java code wouldn't teach me much about agentic coding.

There are several pieces involved, and I still need to understand how they fit together. What is the model responsible for? What turns that model into an agent? How does the agent interact with files and the terminal? How does it know which parts of a project matter? How much information should I give it? What should it be allowed to do without asking me?

Then there are practical questions. Can an agent understand an existing project instead of generating something from scratch? Can it modify multiple files consistently? Can it run tests, understand why they failed, and try to fix the problem? Can I define project rules that it actually follows? Can I keep Git under control while it works?

I don't need the local environment to be amazing at all of those things.

I need it to be good enough that I can experience them.

That's an important difference. If I learn how context affects an agent using a small local model, that knowledge doesn't disappear when I later use a stronger cloud model. If I learn why permissions matter, or why Git gives me an important safety net, those lessons aren't tied to a particular AI provider either.

The tool may change. The fundamentals should travel with me.

Turning the idea into a learning plan

Once I looked at it this way, I didn't want to randomly install AI tools and see what happened. I wanted a path that started with the basics and gradually moved toward a real development task.

So I organized the first stage around one main goal:

Build and evaluate a $0/month local agentic coding environment using the computer I already have.

The plan starts deliberately slowly. Before letting an AI modify a real project, I first need to understand the pieces involved, check what my computer can realistically run, and evaluate local models independently. Only then does it make sense to introduce an agent and give it access to code.

From there, the plan gradually increases the difficulty.

Phase	What I want to learn
0 — Define the experiment	Choose suitable projects and decide what success actually means
1 — Learn the foundations	Understand the main concepts behind models, agents, tools, and agentic workflows
2 — Build the local AI foundation	Find out what my Mac can run and evaluate local coding models
3 — Add the agent layer	Connect a model to something that can actually interact with a project
4 — Define the working rules	Explore project context, instructions, permissions, safety, and a repeatable workflow
5 — Test a real backend project	Move from simple experiments into an existing Spring Boot application
6 — Test a real frontend project	See how the same approach behaves with a Next.js project and a different IDE
7 — Explore cross-project work	Investigate whether the workflow can understand related backend and frontend projects
8 — Understand what the tools are hiding	Explore what would be involved in building a simpler agent loop ourselves
9 — Evaluate the limits	Look at performance, resource usage, and where local models stop being practical
10 — Document what actually works	Finish with a reproducible setup and, more importantly, a clear understanding of its limitations

This is intentionally more than "install a model and ask it to code." If I only test whether a local model can generate a function, I'm evaluating code generation. I'm not really learning how an agent behaves inside a development workflow.

The phases also give me natural stopping points. If something doesn't work, I want to know where it stopped working. Was the computer too limited? Was the model the problem? Was the agent unable to use the model correctly? Did project context become the issue? Did the workflow technically work but require so much supervision that it wasn't useful?

A failed experiment can still teach me something if I know what I was testing.

Using real projects changes the experiment

I also decided early that I eventually wanted to test this against projects I already understand.

For the backend side, I have a Java and Spring Boot personal-finance API that I use with IntelliJ. For the frontend side, I have a Next.js music application that I work on in Visual Studio Code.

That gives me something valuable: a baseline.

I know how these projects are structured. I know the patterns I normally follow, and I have a reasonable idea of how I would implement a change myself. If an agent makes a strange decision, I have enough knowledge of the project to notice it.

That's very different from asking an AI to generate a new application from scratch and then being impressed because the page loads.

Eventually, I want to ask much more practical questions. Can the agent find the correct existing files? Can it understand dependencies? Can it follow the architecture that's already there instead of creating its own? Can it make a small change without touching unrelated code?

Those tests come later. First, I need to build my way toward them.

Zero cost doesn't mean zero compromise

There is one thing I want to be careful about throughout this process.

Running locally is a constraint, not automatically an advantage.

A smaller local model may be slower. It may misunderstand tasks that stronger cloud models handle easily. My 16 GB of memory puts a very real limit on the models I can run comfortably, especially while I'm also using IntelliJ, VS Code, a browser, and everything else I normally keep open while developing.

That's okay.

If the local environment eventually reaches a point where the limitations prevent me from learning anything useful, that is itself an answer. I can move to the next approach knowing why I'm moving instead of simply assuming that paying for a stronger model is the first step.

The point of starting at zero cost isn't to stay at zero cost forever.

It's to make the learning phase inexpensive enough that I can experiment freely.

You don't need my computer to try this

The interesting part of this approach is that the exact hardware isn't really the point.

Your computer may be more powerful than mine. It may be much less powerful. You may use Windows or Linux instead of macOS. You may work primarily with Python, .NET, JavaScript, or something completely different from my projects.

The first question can still be the same:

What can I learn with what I already have?

Start by looking at your environment before looking at a pricing page. Understand what your machine can realistically do. Pick a project you know well enough to judge the results. Define what you're trying to learn instead of simply trying to make AI write as much code as possible.

Maybe your local environment gets surprisingly far.

Maybe it doesn't.

Either result is useful because the objective isn't to prove that local AI is the answer. It's to create enough room to experiment, make mistakes, and understand the fundamentals before money starts influencing every decision.

Let's start with what we have

I started this journey thinking that cost was one of the things keeping me away from agentic coding. Once I recognized that, the next step became much simpler.

I don't need to solve the cost problem permanently.

I just need to remove it long enough to learn.

So instead of starting with credits, subscriptions, cloud GPUs, or the most powerful coding model available, I'm going to start with the M2 Mac already sitting on my desk and see how far it can take me.

Not because I expect it to replace the cloud.

Because right now, I need a classroom more than I need a production-ready AI developer.

And if that classroom costs me nothing, I can afford to make a lot of mistakes.