Skip to content
AFRICAN
TECH BROSay hello
FIND ME ONLINE Let’s talk
Back to the guide library
Build With ThisLAYERSFree guide

The 4 Layers of Claude — L2-L4 Setup Guide

Most people use Claude at Layer 1. Here's how to set up Layers 2, 3, and 4 in 30 minutes — desktop app, your first Skill, and Claude Code.

By Akhil Boddu · AfricanTechBro

TL;DR

Most people use Claude at Layer 1 (browser chat) and wonder why it feels limited. There are four layers. Each unlocks a new capability:

  • Layer 1 — Chat. The browser tab. You type, it answers. 90% of users stop here.
  • Layer 2 — Cowork. Desktop app with file access and project-level rules. Claude stops forgetting what you told it last Tuesday.
  • Layer 3 — Skills. Reusable packaged workflows. You define a Skill once; Claude runs it the same way every time.
  • Layer 4 — Code + Computer. Claude Code in your terminal. Claude reads and edits your actual files. Optionally, Claude controls your mouse and keyboard.

This guide is the setup path for Layers 2, 3, and 4. Thirty minutes, start to finish. At the end you'll have the desktop app installed with a CLAUDE.md defining your rules, one working Skill, and Claude Code running in a real project directory.

Who this is for

You already use Claude for chat. You've written prompts, you've got a few good ones saved, and you're starting to feel like the browser tab is the bottleneck. You're right. The browser tab is the bottleneck.

Prerequisites:

  • A Claude account (free tier works for L2 and L3, Pro/Max recommended for L4)
  • macOS, Windows, or Linux
  • Terminal comfort for Layer 4 (you can skip L4 if you're not there yet)

The 4 Layers at a glance

Layer What it is What it unlocks Time to set up
1 Browser chat Q&A, brainstorm, draft 0 min (you're already here)
2 Desktop app + Projects File reading, persistent rules, MCP 5 min
3 Skills Packaged reusable workflows 10 min for your first one
4 Claude Code + Computer Use Reads/edits your files, runs commands, controls your desktop 5 min install + a lifetime of use 
flowchart LR
    L1[Layer 1: Chat] --> L2[Layer 2: Cowork]
    L2 --> L3[Layer 3: Skills]
    L3 --> L4[Layer 4: Code + Computer]

    L1 -.typed prompts.- L1a[fragile]
    L2 -.project rules + files.- L2a[persistent]
    L3 -.reusable workflows.- L3a[compounding]
    L4 -.full system access.- L4a[autonomous]

Each layer is strictly more powerful than the one below it. You don't replace the previous layer — Layer 4 users still use Layer 1 for quick questions. You just pick the right layer for the job.

Layer 2: Cowork — install the desktop app

What you're doing

Moving off the browser and into the Claude desktop app. The app gives you three things the browser doesn't: proper file reading (drop a PDF in, Claude reads it), Projects with persistent custom instructions, and MCP servers for plugging in external tools.

Why it matters

In the browser, every chat starts from zero. In the desktop app with Projects, every chat inside a project starts with your rules already loaded. You stop re-explaining yourself every time.

Step 1 — Download and install

Get the app from Anthropic directly. Don't install from a third-party site.

  • macOS: https://claude.ai/download — grab the .dmg, open, drag to Applications
  • Windows: https://claude.ai/download — grab the .exe, run it
  • Linux: https://claude.ai/download — .deb and .rpm available

Open the app. Sign in with the same account you use in the browser. Your chat history syncs.

Step 2 — Drop a file in

In a new chat, drag any PDF, image, text file, or code file onto the chat window. Claude reads it immediately. No "upload" step, no preview limits like the browser has.

Try it with a lecture PDF or a document you've been meaning to summarise. Type: /tldr — three bullets and the one thing the author is wrong about. Compare that to copy-pasting into the browser. You won't go back.

Step 3 — Create a Project with custom instructions

Projects are Claude's version of "remember this about me forever for chats inside this folder." You create a project once, paste custom instructions, and every new chat in that project inherits them.

  1. In the desktop app, click Projects in the left sidebar
  2. Click Create Project
  3. Name it something you'll recognise (e.g. Default, Studies, ATB)
  4. In Custom Instructions, paste your rules

Here's a solid starting CLAUDE.md-style block you can paste as your first custom instructions:

# About me
I'm a [your role — student / founder / creator / engineer] based in
[your country]. I work on [1-2 sentence project context].

# How I want you to respond
- Be direct. Skip "Great question!" openers.
- When I ask a yes/no, answer yes or no first, then explain.
- If I'm about to do something dumb, tell me. Don't hedge.
- Use sentence case in headings, not Title Case.
- Prefer short sentences. Vary sentence length.
- When I paste code, assume I want it reviewed, not just reformatted.
- No em-dashes in casual replies (use commas or full stops).

# Voice
Sharp, slightly dry. Colleague explaining, not help-desk agent.

# Defaults
- Default length: just-long-enough.
- Default format: prose unless I ask for a table or list.
- When unsure about a fact, say "[verify]" rather than inventing.

Save. Open a new chat inside that project. Ask it anything. The rules fire automatically.

Tip: Create one project per "context" — one for studies, one for your side hustle, one for personal. Don't try to make one mega-project. Context contamination makes Claude worse, not better.

Step 4 — Projects vs chats (the mental model)

  • Chats are sessions. Each one starts fresh. When a chat gets long, start a new one.
  • Projects are rules + knowledge. Rules live in custom instructions. Knowledge lives in the project's files (drag them in once, every chat in the project can read them).
  • Knowledge base files beat copy-pasting the same document into 20 chats. Put your CV, your brand guidelines, your syllabus, your company wiki — into project files. Claude can then reference them in any chat.

Done when: you have at least one project with custom instructions and at least one file in its knowledge base.

Layer 3: Skills — package a workflow once, run it forever

What you're doing

Creating a Claude Skill — a self-contained, reusable workflow that Claude loads when the task matches. You define it once with its own instructions, example inputs, and any helper files. After that, typing the skill's trigger phrase fires the whole thing.

Why it matters

Projects store rules. Skills store workflows. The difference: a Skill is tool-like. It has a name, a description, a defined input, and a defined output. You can give Claude a library of 20 Skills and it will pick the right one for each task without you managing it.

Step 1 — Meet the Skill Creator

Anthropic ships a Skill Creator — a built-in Skill whose job is to create new Skills. Start there.

  1. In the Claude desktop app, open a new chat in any Project
  2. Type: Use the skill-creator skill to help me build a new Skill
  3. Claude asks what the Skill should do, who uses it, what inputs it takes, and what the output looks like
  4. Answer. Claude generates the Skill's files (SKILL.md, any helpers).
  5. Save the Skill. It's now available to load in any future chat.

Skills live as a folder with a SKILL.md file at the root. The SKILL.md has YAML frontmatter (name, description, allowed tools) and a body of instructions. That's it. No magic.

Step 2 — Three Skills worth building first

Pick one. Build it. Use it for a week. Then build the next.

1. Lecture PDF Summariser

  • Trigger: summarise this lecture
  • Input: PDF dropped into chat
  • Output: 5-bullet overview, 3 likely exam questions, 1 concept the lecturer glossed over
  • Why this one first: highest value-per-minute you'll get out of AI as a student. You read the 5 bullets in 2 minutes, then decide whether you need to watch the lecture.

2. Weekly LinkedIn Draft from Notes

  • Trigger: draft this week's post
  • Input: paste 3-5 bullet points from your week
  • Output: one LinkedIn post (180-220 words) in your voice, with a hook in the first line and a CTA in the last
  • Why this one: forces you to post weekly without the Sunday-night blank-page tax.

3. Thesis / Essay Proofread in Your Voice

  • Trigger: proofread in my voice
  • Input: paste a paragraph or upload a doc
  • Output: edited version that fixes grammar and clarity without replacing your vocabulary or sentence patterns. Flag anywhere the edit might have changed meaning.
  • Why this one: kills the "this reads like AI wrote it" problem on anything you submit.

Step 3 — How to trigger a Skill

Once the Skill is saved, you trigger it three ways:

  1. Explicitly: type Use the [skill-name] skill to [task]
  2. Implicitly: ask Claude to do the thing. If your description matches the Skill's description, Claude picks it up automatically.
  3. From Claude Code: Skills you create in the desktop app are usable from Claude Code too (Layer 4). Skills are cross-surface.

Step 4 — Scheduling Skills

If a Skill should run on a schedule (e.g. "every Monday at 9am, summarise my week"), you have two options:

  • Desktop app: use a Skill inside a chat and set a reminder in your calendar to trigger it manually. There's no native scheduler in the app yet.
  • Claude Code: from the terminal, use cron or launchd (macOS) to run claude with a prompt that loads your Skill. This is Layer 4 territory — covered next.

Watch out: don't try to build one giant Skill that does everything. Skills are like functions. Small, composable, each does one thing. If you find yourself adding a fifth clause to a single Skill, split it into two.

Done when: you have one Skill you've triggered at least twice, and it saved you real time on the second run.

Layer 4: Code + Computer — Claude Code in your terminal

What you're doing

Installing Claude Code — Anthropic's official command-line tool that lets Claude read and edit files in any folder on your machine, run shell commands, and chain operations without you copy-pasting.

Why it matters

Layers 1-3 live inside Claude's UI. Layer 4 leaves the UI. You open your terminal, run claude inside your project directory, and now Claude has hands. It can read your entire codebase, edit 30 files at once, run tests, commit to git, and hand the output back to you.

It also works for non-code. A folder full of Markdown notes is "code" to Claude Code. A directory of transcripts is "code". If it's a file on your disk, Claude Code can work with it.

Step 1 — Install

Install Claude Code globally via npm. You need Node.js 18+ installed first (node --version to check).

npm install -g @anthropic-ai/claude-code

If you don't have Node, grab it from https://nodejs.org (use the LTS version) or via Homebrew on macOS: brew install node.

After install, verify:

claude --version

You should see a version number. If you get "command not found", your npm global bin isn't in your PATH. Fix: npm config get prefix gives you the prefix; add <prefix>/bin to your shell profile (.zshrc or .bashrc).

Step 2 — First run

Navigate to any project folder and run claude:

cd ~/Documents/my-project
claude

First time, it'll ask you to sign in. A browser tab opens, you authorise, you come back to the terminal authenticated.

Now type a prompt. Try something real:

Read the files in this folder and give me a one-paragraph summary of
what this project does and who it's for.

Claude reads the files. Tells you what it found. You didn't upload anything, you didn't copy-paste anything. Your files stayed on your machine.

Step 3 — Give it a CLAUDE.md

Claude Code reads a CLAUDE.md file at the root of your project automatically. This is where you put project-specific rules, context, and commands — the same concept as Projects in the desktop app, but file-based and version-controlled with the rest of your code.

Create one:

touch CLAUDE.md

Paste in something like:

# Project: my-project

## What this is
[1-2 sentence project description]

## Stack
- [language, framework, key libraries]

## Conventions
- [naming rules]
- [file structure rules]
- [testing approach]

## Do not
- [anti-patterns specific to this project]
- [dependencies you don't want added]

## Common commands
- Build: `npm run build`
- Test: `npm test`
- Dev: `npm run dev`

Restart claude in that directory. The CLAUDE.md is loaded. Every question you ask from now on knows the project's conventions.

Step 4 — A useful first command

Here are three commands that pay for the install by themselves.

Clean up a messy folder:

Look at the files in this folder. Rename anything that doesn't follow
the kebab-case convention in CLAUDE.md. Show me the renames before
doing them.

Refactor across files:

The function `calculateTotal` in src/lib/cart.ts is called from 7
places. Refactor it to return { subtotal, tax, total } instead of
just the total. Update all 7 call sites. Run the tests after.

Onboard yourself to a new codebase:

I just cloned this repo. Read the README, the package.json, and the
top-level folders. Explain what this app does, what the entry point
is, and where I should start reading to understand it.

Step 5 — Computer Use (handle with care)

Computer Use is the Layer 4.5 capability: Claude can click, type, and navigate your actual desktop. Think of it as Claude controlling a VNC session.

It's powerful. It's also the riskiest layer. You're handing a keyboard and mouse to an AI. It can open your email, your files, your browser. It can also misclick, close work, or send a message you didn't intend.

Safety rules if you use it:

  • Run it in a separate user account or a VM if you're doing anything sensitive
  • Never run it unattended on a machine with financial/admin access
  • Give it narrow, bounded tasks (e.g. "open Chrome, go to this URL, fill this form with this data, screenshot the result")
  • Watch the whole session. Don't walk away.

You access Computer Use via the Claude API (not the desktop app) or via beta features in Claude Code. If you're new to Layer 4, skip Computer Use for the first month. Get comfortable with the file-editing capabilities first.

Step 6 — Spawn parallel agents

One of the biggest unlocks at Layer 4: you can ask Claude Code to spawn sub-agents that work on independent parts of a task in parallel. Instead of one Claude doing 10 things sequentially, you get 5 Claudes doing 2 things each at the same time.

Example prompt:

I need to update the pricing on 5 product pages, each with its own
components. Spawn 5 parallel agents, one per page. Each agent
reads its page, updates the price, and runs the type-check. Merge
results at the end.

Parallel agents are how you get serious work done quickly without babysitting. Use them when: tasks are independent, outputs don't conflict, and you can verify results at the end.

Done when: you've run claude in at least one real project directory, added a CLAUDE.md, and completed one multi-file edit.

The 30-minute path

Here's the exact order. Time-boxed. No detours.

  1. [5 min] Install the desktop app. macOS/Win/Linux from claude.ai/download. Sign in.
  2. [5 min] Create one Project with custom instructions. Paste the starter block above. Adjust one or two lines to fit your context.
  3. [10 min] Build your first Skill. Pick one of the three above (Lecture Summariser is the fastest). Use Skill Creator. Test it twice.
  4. [5 min] Install Claude Code. npm install -g @anthropic-ai/claude-code, then claude in any project directory.
  5. [5 min] Write a CLAUDE.md and run one command. Doesn't matter which command. What matters is that you've used it once.

Done. You're now operating at Layers 2, 3, and 4. The browser tab is no longer your bottleneck.

What's next

  • Build Skill #2 and #3. The compounding starts after you have 3+ Skills you actually use. At 5 Skills you start thinking of Claude as a team member.
  • Put CLAUDE.md in every serious project. Commit it. The file is a living document that makes every future Claude Code session in that repo better than the last.
  • Join the ATB community. If you're building with AI in South Africa, we're running a community of vibe-coders and creators using this stack. DM me LAYERS on IG for updates on the next meetup.
  • Check out noface.video. ATB Labs' faceless-video tool — built end-to-end with Claude Code. Good example of what Layer 4 actually enables.
  • One more layer (L5) is coming. Custom agents and long-running autonomous workflows. We'll cover it in a follow-up guide when the features stabilise.

If a specific step breaks for you, DM me on Instagram with a screenshot. I'll update the guide.