The IKEA Guide to AI Tools. When the Chair Looks Like a Cupboard.

I didn’t read any documentation when I started using Claude Code and Codex. I just dove in. Opened both tools, pointed them at my files, and ran amok.

This is how I learn best. Mucking in. Being surprised by what a tool can do. Finding the edges by falling off them.

It’s no different to building an IKEA flat pack. You think you can do it without the manual. You’re going fine. Then suddenly a chair looks like a cupboard and you’re holding a piece you don’t recognise.

That’s basically my AI coding journey so far. And eventually I went looking for the manual. Both Anthropic and OpenAI have official best practice guides. They’re thorough, detailed, and written for developers. I’m not a developer. I’m a copywriter who runs a small business.

So I waded through the jargon and pulled out the bits that actually matter for someone like me. This is the non-coder’s playbook I wish I’d had from the start.

1. The mindset shift — from chatbot to co-developer

The biggest thing I had to unlearn was treating AI like a search engine. You ask a question, it gives you a snippet, you copy-paste. That’s a chatbot. Claude Code and Codex aren’t chatbots.

They’re agentic coding environments. That’s the official term. In plain English, it means the AI can read your files, run commands, and make actual changes to your project while you watch or step away. You don’t copy-paste anything. It does the work itself.

The shift is this. You stop writing code and start describing outcomes. You define the “what” and let the AI figure out the “how.”

I’m a copywriter, so this actually makes sense to me. I don’t need to know how the brackets and semicolons work. I need to describe what I want the end result to look like. The AI handles the syntax. My job is intent. Its job is execution.

But here’s the catch I didn’t see coming. This only works if the AI has a memory of your project’s rules. Without that, it’s like hiring a new contractor every time you start a chat. Smart, capable, and completely clueless about how your project works.

2. Project memory — CLAUDE.md and AGENTS.md

Both tools have a way to give the AI long-term memory about your project. Claude Code uses a file called CLAUDE.md. Codex uses AGENTS.md. Same concept, different names.

These files sit in your project folder and the AI reads them every time it starts a new session. Think of it as a manual for your AI teammate. It tells the AI what your project is, what rules to follow, and what to avoid.

I didn’t know these existed for ages. I was typing the same instructions over and over every time I started a new chat. “Use this colour palette. Don’t add new libraries. Run the linter after changes.” Every. Single. Time. Like a chump.

Then someone mentioned you can auto-generate a starter file by typing /init. One command. The tool scaffolds the file for you. I genuinely didn’t know that.

What to include and what to leave out

The guides are clear about this. If the file is too long, the AI will ignore your instructions. Keep it concise.

Include things like specific naming conventions, build and test commands, libraries to avoid, and environment quirks the AI can’t guess. Leave out things the AI already knows (“write clean code”), anything it can see by reading your files, data that changes daily, and giant documentation dumps — give it a URL instead.

My CLAUDE.md file started way too long. I pasted in everything. Style guides, API docs, half the internet. The AI ignored most of it. Now I keep it tight. Three sections — architecture rules, workflow, verification. That’s it.

Global vs project files

One thing that confused me. You can have global instructions AND project instructions. Global lives in your home folder and applies to everything. For Claude that’s ~/.claude/CLAUDE.md. For Codex it’s ~/.codex/AGENTS.md. Project files live in your repo and override the global ones.

Think of it like this. Global is your general work habits. Project is the specific rules for one job. You can set teammate-wide habits once, then fine-tune per project.

3. The workflow — explore, plan, execute

Both guides say the same thing here. Don’t just tell the AI to start coding. Let it explore first, plan second, then execute. The official term is “separating research and planning from implementation to avoid solving the wrong problem.”

I skipped this step constantly when I started. I’d just say “fix this” or “build me this page” and let the AI go wild. Sometimes it worked. More often it built something close to what I wanted but not quite right. Because I hadn’t described the outcome clearly enough.

The four phases are simple. Explore — use plan mode to let the AI read your files and understand the project. Plan — ask for a step-by-step implementation plan. Implement — switch out of plan mode and let it build. Commit — once it’s done and verified, ask it to commit the work.

In Claude Code, you enter plan mode through the terminal. In Codex, you toggle it with /plan or Shift+Tab. Either way, the AI researches without changing anything. Then you review the plan, adjust if needed, and tell it to go.

Codex also lets you set reasoning effort. Low for fast, simple tasks. Medium or high for complex debugging. Extra high for long, autonomous, reasoning-heavy work. I didn’t know this existed. I was running everything on the default and wondering why simple tasks took forever and complex ones felt rushed.

One exception. If you can describe the change in a single sentence — “change the submit button colour to blue” — skip the plan and go straight to implementation. Planning adds overhead. For small tasks, it’s not worth it.

4. Trust but verify — closing the loop

This is the section that clicked for me. As a non-coder, your primary role isn’t writing code. It’s quality control. You need to give the AI a way to check its own work.

Anthropic’s guide puts it perfectly. “Give Claude a check it can run. It’s the difference between a session you watch and one you walk away from.” Without a check, the guide says, “looks done” is the only signal available. The AI tells you it’s finished and you have to take its word for it.

Give it something that produces a pass or fail — a test, a build, a screenshot to compare — and the AI can check itself. It runs the check, reads the result, and iterates until it passes.

I was doing this all wrong. I’d ask the AI to build something, it would say “done,” and I’d trust it. Then I’d preview the page and find it was broken. The AI hadn’t checked anything. It just told me it was finished because it looked done.

Now I include verification in every prompt. “Build the contact form. Run the linter, take a screenshot to verify alignment, and iterate until the build succeeds.” That one sentence changed everything. The AI stops when it’s actually done, not when it thinks it looks done.

5. Force multipliers — skills, subagents, and MCPs

Once you’ve got the basics working, there are three features that make everything faster. I didn’t know any of these existed until recently.

Skills

Skills are repeatable workflows saved in a SKILL.md file. You package up a multi-step task once, then trigger it with a single command next time. Both Claude Code and Codex support them.

For a non-coder, this is gold. Instead of typing out the same long instructions every time — “check spelling, fix formatting, verify links, preview the page” — you save it once as a skill and trigger it with one word.

I was typing the same paragraphs of instructions over and over. Someone mentioned you can use /skill-creator to turn any successful workflow into a permanent skill. That would have saved me hours a week.

Subagents

Subagents are specialised assistants running in their own separate brain space. You delegate heavy research or code reviews to them so your main conversation stays clean and focused.

This ties directly into context window management, which we’ll get to. The point is you can offload work to a subagent without cluttering your main chat. I wasn’t doing this. I was doing everything in one conversation. No wonder it got messy.

MCP — Model Context Protocol

MCP is a standard that connects the AI to external data. Notion, Figma, your live database, issue trackers — all natively. No custom middleware. No API integration code to write.

For a small business owner, this matters because you might assume you need a developer to connect your tools. You don’t. Both Claude Code and Codex support MCP servers out of the box. Add them via the settings and the AI can talk to your external services directly.

6. Respecting the limits — managing the context window

This is the section I needed most. Every AI has a context window — a short-term memory that fills up with every file read and message sent. When it fills, performance degrades. The AI starts forgetting earlier instructions and making mistakes.

Anthropic’s guide is blunt about this. “Most best practices are based on one constraint. Claude’s context window fills up fast, and performance degrades as it fills.”

OpenAI’s guide lists “using one chat for an entire project instead of one chat per coherent outcome” as a common mistake. Their words. “This leads to bloated context and worse results over time.”

I am so guilty of this. I let one chat go on forever. Build something, fix something else, check a totally unrelated thing, go back to the first thing. By the end, the AI is confused and I’m confused and nobody remembers what we were originally doing.

Think of it like a kitchen bench. If you keep adding ingredients without wiping down, eventually you can’t find the flour. Clean bench, clean bake. Clean chat, clean code.

The refresh commands

Both tools have built-in commands to manage context. I didn’t know any of these existed.

/clear resets the conversation completely. Use it when you’re switching from one task to something totally different — like moving from fixing the footer to migrating the database.

/compact summarises the important context to save space without starting over. Codex features “first-class compaction” which enables long conversations without losing key project states. This is my favourite. It keeps the important bits and drops the noise. Like clearing the scraps off the bench but keeping the recipe.

/rewind lets you undo the conversation to a specific point if the AI goes down a rabbit hole. And /context shows you exactly which files the AI is currently thinking about.

There’s also /btw for side questions that shouldn’t stay in the AI’s memory. I use this when I want to ask something quick without polluting the context window.

7. Three traps I fell into (and how to avoid them)

OpenAI’s guide and the NotebookLM research both highlight common mistakes beginners make. I’ve made all three.

The Kitchen Sink Session

Asking for five unrelated things in one chat. Fix the footer, check the database, write a blog post, update the pricing page, and oh while you’re at it can you look at this error? All in one conversation. By the end, the AI has no idea what project it’s working on and neither do you. Use /clear between unrelated tasks.

Infinite Exploration

Asking the AI to “investigate the project” without a goal. It just keeps reading files and summarising and you never actually build anything. Scope your questions narrowly. “How does the login file handle tokens?” is useful. “Look at everything” is not. Or delegate the search to a subagent so it doesn’t clutter your main context.

Correcting Over and Over

Correcting the same mistake three times in a row. If the AI gets it wrong twice, the context is probably cluttered. Stop. Run /clear and start fresh with a more specific prompt. You’re not helping by correcting the same thing in the same messy chat.

One more — don’t mix tools on the same folder

This isn’t in the official guides but it’s the mistake that cost me the most time. I pointed Claude Cowork at my Codex folder, thinking it could pick up where Codex left off. Two different tools, same files, no shared context. Each tool has its own picture of what the project is and what’s been changed. Everything got knotted and I had to start the whole project again.

One project, one AI tool. If you want to switch tools, copy your files to a fresh folder and start there. Don’t make them share.

Windows and PowerShell

One practical note from the research. If you’re working in a Windows or PowerShell environment, Codex is your preferred teammate. It has first-class support for these environments, leading to fewer command-line errors. Something to keep in mind if you’re on a Windows machine.

The IKEA lesson

Here’s the thing about the IKEA analogy. The manual isn’t complicated because IKEA wants to confuse you. It’s complicated because furniture has a lot of pieces and they all need to go in the right place.

Same with AI coding. The documentation isn’t written in jargon to keep you out. It’s written in jargon because the people who built the tools think in jargon. But the principles underneath are simple.

Shift from chatbot to teammate. Give the AI project memory. Explore before you build. Verify the work. Use skills and subagents to multiply your output. Keep the context window clean. And avoid the three traps.

I’m still figuring this out. I’m still making mistakes. But at least now I know the manuals exist, even if I still can’t fully understand them. The official guides are at anthropic.com/engineering/claude-code-best-practices and developers.openai.com/codex/learn/best-practices.

You don’t need to understand every word. You just need to know which bits apply to you. And if you’re a non-coder using AI to build things — which is most of us now — all of it applies. You just need someone to translate it first.

Or get in touch directly and I’ll help you figure out which AI tools make sense for your business.

Frequently asked questions

Some links in this post may be affiliate links. If you click through and make a purchase, I may earn a commission at no extra cost to you. I only recommend tools and services I actually use. Written by a human. Affiliate links may apply. Nuffin’s for free.