← All Guides

The Non-Coder's Toolkit: AI Tools, Automation, and Building Your Workflow

This is the final part of The Stackless Guide. Part 1 covered security. Part 2 covered testing. This part is about the tools themselves: what they are, how to pick between them, and how to build an increasingly powerful workflow without writing a single line of code yourself.

When I started using AI coding tools, I thought the tool was the whole thing. You type what you want, the AI builds it. That's it, right?

It's not. Over months of building real projects, I've assembled a toolkit of techniques, scripts, and habits that multiply what I can accomplish. The AI does the coding. But the workflow around it, how I manage context, how I recover from crashes, how I run things overnight, that's the real multiplier.

The AI Tools Landscape: What's What

There are now dozens of AI coding tools. Here are the ones I've actually used or seriously evaluated, organised by what they're good at:

Claude Code (Anthropic)

This is my primary tool. Every project on this site was built with Claude Code. Its strength is working with entire projects: it can read file A, understand its relationship to file B, and make coordinated changes across both. It also stays on your machine, which matters for privacy (see Part 1).

Gemini with Canvas (Google)

Gemini Canvas is great for visual work. If I need a quick landing page, a styled component, or I want to iterate on how something looks, Canvas lets me see changes immediately in the browser. It's less powerful than Claude Code for multi-file projects, but the visual feedback loop is faster.

My typical workflow: start a project's visual design in Gemini Canvas (fast iteration, immediate preview), then move to Claude Code for the full build (multi-file, backend, data processing).

ChatGPT with Canvas (OpenAI)

How I Pick the Right Tool

Here's my actual decision process:

• Quick visual prototype? Gemini Canvas. Fastest path to "I can see something."
• Processing local data (spreadsheets, files)? Claude Code. It needs to be on my machine to read my files.
• Multi-file project with coordinated changes? Claude Code. Nothing else handles project-wide context as well.
• Just need a quick answer or one-off script? ChatGPT or Gemini, whichever tab is already open.
• Sensitive data involved? Claude Code (local) or nothing cloud-based at all.

Don't get locked into one tool. I regularly use 2-3 tools on the same project. Generate the design in Canvas, build the full app in Claude Code, use ChatGPT to explain a concept I don't understand. Each tool has strengths. The skill is knowing which to reach for.

The Skill That Changes Everything: Custom Instructions

Every AI tool lets you set custom instructions (sometimes called "system prompts" or "custom profiles"). This is a document that the AI reads before every conversation, telling it who you are, what you prefer, and how to work with you.

This is probably the single highest-impact thing a non-coder can learn, because it transforms the AI from a generic assistant into one that knows your preferences, your projects, and your way of working.

In Claude Code, this file is called CLAUDE.md and lives in your project folder. ChatGPT has "Custom Instructions" in settings. Gemini has "Gems" that serve a similar purpose. Different names, same concept: teaching the AI about you once, so you don't have to repeat yourself forever.

Building Automation: From Manual to Overnight

This is where things get powerful. And I want to be honest: this part took me months to figure out, building one piece at a time. You don't need all of this on day one. But I want to show you where you can get to, so you know what's possible.

Level 1: Saving Repetitive Prompts

If you find yourself typing the same kind of instruction over and over, save it as a template. This is the most basic automation there is, and it works with any tool.

Level 2: Custom Skills (Claude Code Specific)

Claude Code lets you create "skills", which are reusable commands you trigger with a slash. I've built 12 of these so far, each one saving me repetitive work:

• /checkpoint saves my current progress (commits to git, writes a state file)
• /wrap-up runs end-of-session tasks (saves progress, updates my personal dashboard, extracts lessons learned)
• /pickup reads the state file from last session and resumes where I left off
• /research performs deep web research on any topic, saves findings to files
• /organize audits and cleans up my file structure

Each skill started as something I did manually. After doing it manually 3-4 times, I told Claude Code: "Turn what I just did into a reusable skill." It built the skill file, I tested it, and now it's a one-word command.

Level 3: Hooks (Automatic Reactions)

Hooks are scripts that run automatically when certain things happen. Think of them as "if this, then that" for your AI tool.

For example, I built a notification hook: when Claude Code finishes a long task or hits a rate limit, a desktop notification pops up so I know to come back. Without this, I'd be constantly checking whether it was done yet.

Hooks are powerful but can cause problems if you're not careful. I learned this the hard way when a hook I built started scanning my conversation for keywords and triggering false alerts whenever I merely discussed the concept of "rate limits" rather than actually hitting one. The fix was simple (make it read system messages, not the conversation) but the lesson was important: hooks run automatically, so test them well before relying on them.

Level 4: Overnight Automation

This is the most advanced thing I do, and I'm sharing it because it shows what's possible, not because you should try it on day one.

I built a custom skill that runs Claude Code while I sleep. It scans my projects for useful work to do (expanding content, fixing known issues, running research), executes tasks in careful loops with regular saves, and handles rate limits by pausing and restarting automatically.

The practical setup on Windows:

1. A PowerShell script monitors the Claude Code process
2. If Claude Code hits a rate limit and pauses, the script waits for the cooldown period and then resumes
3. Regular checkpoint saves mean that if anything crashes, work isn't lost
4. A context management system compresses long conversations so the AI doesn't lose track of what it's doing

People with Mac Minis take this further: they dedicate an entire machine to running AI tasks 24/7. The Mac Mini sits on a shelf, connected to the internet, running coding tasks while the owner sleeps, works, or lives their life. It's essentially a personal AI employee working on a dedicated workstation.

The Iterative Learning Approach

Here's something important that no tool's marketing page will tell you: the first thing you build will be rough. The second will be better. By the tenth, you'll be building things you couldn't have imagined at the start.

This is not about learning to code. It's about learning to communicate with the AI effectively, to set up your environment, to recognise when something is wrong, and to build habits that compound over time.

I went from "how do I open a terminal?" to running overnight automation in about four months. Not because I'm clever, but because each project taught me something I applied to the next one.

Here's the actual progression:

1. Month 1: First project. A simple dashboard. Learned: how to open Claude Code, what a file path is, how to open HTML files in a browser, what git is and why it matters.
2. Month 2: Second and third projects. More dashboards, a web app. Learned: how to work with data files, how to debug using browser console, that AI makes mistakes and I need to verify.
3. Month 3: Multiple parallel projects. Learned: custom instructions (game changer), git branching, the sample-then-scale approach, how to structure bigger projects across multiple files.
4. Month 4: Automation and workflow. Built custom skills, hooks, a notification system. Started running sessions overnight. Learned: the tool is 20% of the value, the workflow is 80%.

Each month wasn't planned. I didn't sit down and think "I will learn git branching this month." I just hit a problem (I lost some work), figured out the solution (git), and never had that problem again. That's how iterative learning works: you learn what you need when you need it.

What You Actually Need to Get Started

If you're reading this and haven't started yet, here's the minimum setup for different approaches:

Absolute Minimum (No Installation)

Next Level (Local AI Tool)

The Mac Mini Setup (Dedicated AI Workstation)

If you're serious about AI-assisted building and want a dedicated machine, the Mac Mini is the popular choice in the community. Here's why and how:

• Why Mac Mini? Low cost (~£500-800 for the M-series models), low power consumption (runs 24/7 for pennies), macOS has good terminal/developer tool support, small form factor (lives on a shelf or behind a monitor).
• The setup: Install Node.js, install Claude Code (or whichever AI tool you prefer), set up remote access so you can control it from your main computer.
• How people use it: SSH (remote terminal access) from their main computer or phone. Start a Claude Code session on the Mini, let it run, check back later. The Mini handles the AI work while your main computer stays free for everything else.
• Security benefit: Your sensitive files stay on your main computer. The Mini only has the project files you deliberately copy to it. Physical isolation: the strongest security boundary.

You absolutely do not need a Mac Mini to start. I don't have one (yet). But if you find yourself running into rate limits, wanting to run things overnight, or just wanting to keep AI work separate from your personal computing, it's a genuinely practical investment.

Docker: The Isolation Layer Explained

Docker comes up a lot in AI tool discussions. In Part 1, I mentioned it as a security tool. Here's the practical side for non-coders:

Think of Docker as a sealed room inside your computer. You put your project in the room, the AI works on it inside the room, and nothing inside can access anything outside unless you explicitly open a door.

If you want to try Docker:

1. Install Docker Desktop from docker.com (free for personal use)
2. It adds a "Docker" app to your computer. Open it.
3. From there, you can run containers. Many AI tools provide Docker images (pre-made containers) that you can run with one command.

Docker is not required for anything in this guide. It's an advanced safety tool. But understanding what it is helps you understand conversations in the AI builder community, and when someone says "just run it in Docker," you'll know what they mean.

Maximising Your AI Subscription

Most AI subscriptions have usage limits. Claude Pro gives you a certain amount of usage per day, ChatGPT Plus has limits, Gemini Advanced has limits. Here's how to get the most from what you're paying for:

Be Specific, Not Vague

Vague prompts waste tokens (and therefore usage). "Make it better" requires the AI to guess what "better" means. "Make the chart labels larger and change the colour scheme to dark blue and white" is one round trip instead of three.

Batch Your Requests

Instead of asking for one thing at a time across five separate messages, list everything you want in a single message. "Change these five things: 1) make the header smaller, 2) add a footer with copyright, 3) change the font to Inter, 4) make the background light grey, 5) add a mobile menu." One message, one response, five changes.

Use the Right Model for the Task

Many tools offer different models at different costs. In Claude Code, I use the faster model (Sonnet) for routine work like file organisation and simple edits, and the more powerful model (Opus) for complex architecture, nuanced writing, or debugging that stumped the faster model. This stretches my subscription significantly: most tasks don't need the most powerful model.

Context Management

AI tools have a "context window", how much they can remember from the current conversation. As the conversation gets longer, the AI starts forgetting earlier details. I manage this by:

• Saving progress regularly (so I can start fresh without losing work)
• Compacting conversations (a Claude Code feature that summarises the history)
• Starting new sessions for new topics instead of continuing one massive conversation
• Keeping important information in files (like CLAUDE.md) that the AI reads at the start, rather than relying on conversation memory

The "Don't Be Afraid to Try" Philosophy

I want to end with this because it's the most important thing in the whole guide.

You are going to break things. Files will have errors. The dashboard will show wrong numbers. The web app will look terrible on your phone. A git commit will include something it shouldn't. You'll accidentally overwrite something and have to figure out how to get it back.

All of this is normal. All of this is how learning works.

The reason I can build things now that I couldn't six months ago isn't that I became a developer. It's that I tried, failed, fixed, and tried again enough times that the patterns became familiar. I know what the browser console looks like. I know what "git status" shows me. I know to save before making changes. I know to check the numbers against my source data.

None of this came from a course or a tutorial. It came from doing the work, making the mistakes, and building the safety nets (git, backups, the "move don't delete" rule) that make those mistakes recoverable.

The only real mistake is not trying. Everything else is just debugging.

So here's my actual advice for getting started:

1. Pick one project. Something small that you'd actually use. A birthday tracker, a recipe organiser, a simple budget calculator.
2. Pick one tool. Gemini Canvas for the easiest start. Claude Code if you want more power and are willing to use a terminal.
3. Build it. It will be rough. That's fine.
4. Use it for a week. Note what's wrong, what's missing, what's annoying.
5. Fix those things. Ask the AI for each fix.
6. Start your next project. You'll be noticeably faster and more confident.
7. Repeat forever. Each project teaches you something the last one didn't.

That's it. That's the whole method. Try things, check if they work (Part 2), keep your data safe (Part 1), and build the tooling around you as you go.

Welcome to building without the stack.