I didn't build SafeDevTools by asking AI to "build me a website." I built it by treating a local LLM like a junior engineer who never gets tired of writing boilerplate.
A few weeks ago, I challenged myself with a simple experiment:
Could I build a production-ready product using nothing but a local LLM?
Just: VS Code, Ollama (Gemma 4:12B), my MacBook M4 Pro, and a lot of software engineering experience.
The result was SafeDevTools — a collection of privacy-first developer utilities that run entirely in the browser.
👉 https://safedevtools.com I wrote about the technical "How-To" in my previous article:
This article is about the mental shift. It’s about how I changed the way I think about software development after building this product.
Every week, social media is flooded with:
"AI built an entire SaaS in 24 hours."
"AI replaces software engineers."
These videos are entertaining, but they miss the point. After spending weeks building a real product with a local model, I realized that the value of AI isn't replacing the engineer.
The value of AI is replacing repetitive engineering work.
That is a massive distinction. One is about replacement; the other is about leverage.
Think about your first few years as a developer. Most of your day was spent asking:
Back then, writing code was the job.
Fast forward a few years. Your role has shifted. You spend your time thinking about:
The irony? Despite becoming responsible for high-level system design, you are still often tasked with writing hundreds of lines of repetitive "grunt work."
The CRUD endpoints. The validation logic. The DTOs. The unit tests. The accessibility attributes.
The code isn't always difficult—it’s just repetitive.
SafeDevTools consists of multiple utilities. Every tool follows the same design language:
I could have written every page manually. But by the third or fourth tool, I realized something: I wasn't solving engineering problems anymore; I was repeating myself.
That is where the local LLM became my superpower. Not because it "invented" the tools, but because it executed the repetition with perfect consistency.
A key takeaway from this project was learning to separate Intent from Execution.
I found that the most effective workflow is for the human to remain the Architect (Vision, Design, and Standards) while the AI serves as the Builder (Repetitive Tasks, Boilerplate, and Testing).
The mindset shift: The model isn't making product decisions. It is implementing my decisions.
If you want better results, stop using "God-mode" prompts like: "Build me a dashboard."
Instead, treat the LLM as an implementation engine. Use specific, measurable engineering tasks:
Pro Tip: These are smaller, discrete tasks. They are exactly where smaller local models perform surprisingly well.
Early on, I made the mistake of feeding the model my entire project folder. The results were messy and hallucinatory.
I learned that instead of increasing the prompt size, I needed to reduce the problem scope. Give the model:
The smaller the context, the higher the quality of the output. This forced me to be a better architect because I had to define the boundaries more clearly before asking for code.
This was my most unexpected "Aha!" moment. The secret wasn't a complex prompt; it was Standard Operating Procedures (SOPs).
I started documenting everything:
Eventually, this evolved into a reusable set of instructions that acted as the "Source of Truth." Once the model understood my project's rules, every new tool became easier to generate.
The documentation became more valuable than any prompt. The AI stopped guessing and started following orders.
This is the ultimate mental model.
Imagine a talented junior developer joins your team today. You wouldn't tell them: "Build our entire platform." They would be overwhelmed and fail.
Instead, you would give them:
Then, you review their work.
That is exactly how I use a local LLM. It doesn't replace me; it extends my capacity to build.
People ask why I don't just use GPT-4 or Claude for this. It’s not about replacing those models; it’s about Workflow.
The local model is simply another tool in my stack, sitting alongside Docker, Git, and PostgreSQL.
I need to be clear: AI did not build SafeDevTools.
The implementation simply became dramatically faster because I had an assistant that never complains about writing repetitive code.
The future isn't about "Autonomous Agents" replacing engineers. It’s about experienced developers who know how to combine their Engineering Intuition with AI-Assisted Implementation.
Experience tells you what should be built. AI helps you build it faster.
Stop asking AI to replace you. Start using it to unburden you.
🌐 SafeDevTools
https://safedevtools.com 📝 The Technical Deep Dive
How I Built SafeDevTools Using a Local LLM