Forem: Phillip A. Wessels

Containers & Agents with Docker & OpenClaw

Phillip A. Wessels — Tue, 26 May 2026 22:36:12 +0000

You have a fundamental problem in software: your code works on your machine, but breaks on someone else's. Different operating systems. Different versions of dependencies. Different configurations. "It works on my machine" is the oldest excuse in development.

There's another problem too: packages. You install npm packages to build things faster. But what if a package has malicious code? What if it goes rogue and tries to access your system files? Without isolation, one bad package can compromise everything.

Containers solve both problems. A container packages your application plus everything it needs to run—the exact runtime, the exact dependencies, the exact configuration—into a single, portable unit. It also isolates your application in a sandbox: if a package misbehaves, it's confined to that container. It can't touch your other projects or your system files. The same container runs on your laptop, a colleague's Mac, and a production server. No surprises. No risk spillover.

Docker is the standard tool for building and running containers. This guide teaches you what Docker does, how it works, and why it matters.

Once you understand Docker, we can apply it as a solution for a specific problem: containing an agent—OpenClaw—so it can run without accessing your entire system. We'll set that up, connect it to Discord, and you'll have deployed your first production system.

The Problems Containers Solve

Imagine you're running an application on your laptop. It works fine. But then:

Your application depends on Python 3.11, but you upgrade to Python 3.12 for another project. Now the first application breaks.
You want to deploy the application to a server. You install dependencies, but the server has a different OS version or different package versions. Things behave differently.
Your application crashes. It stays down until you manually restart it.
You install a sketchy npm package for one project. It misbehaves and starts corrupting files. It affects your entire system.
You want to run the same application on Windows and macOS. You need different installation instructions for each platform. Developers always forget a step.

These are the problems containers solve:

Reproducibility — The same container runs identically on your laptop, a colleague's Mac, a staging server, and production. No "works on my machine" surprises. No platform-specific configuration nightmares.

Isolation — Each container is sandboxed. One application's dependencies don't conflict with another's. A misbehaving package or crashed application or AI agent (like OpenClaw) is confined to its container—it can't damage your system or other projects.

Reliability — If an application crashes, the container can automatically restart it. Long-running services stay alive without manual intervention.

Deployment simplicity — You don't install your application on a server. You just run the container. Same image, same behavior, everywhere.

What is Docker?

Docker is a containerization platform. It packages your application—plus everything it needs to run—into a single, portable unit. Think of it this way:

Without Docker — You ship code to someone and say, "Install Node.js 24, npm 11, these 50 packages, and run this." Hope their setup matches yours.
With Docker — You ship a container. It includes Node.js 24, npm 11, all 50 packages, and your code. It runs identically everywhere.

The Mental Model: Images and Containers

A Docker image is a blueprint—a template that describes how to build an environment. It's like a recipe.

A Docker container is a running instance of that image. It's like baking a cookie from the recipe.

You create one image. You can run multiple containers from it. Each container is isolated and independent.

The Dockerfile: Your Recipe

To build a Docker image, you write a Dockerfile—a set of instructions. Here's an example:

FROM node:24-slim
WORKDIR /app
RUN npm install -g some-app
ENV PORT=3000
VOLUME ["/data"]
CMD ["some-app", "start"]

Each instruction does something:

Instruction	Meaning
`FROM node:24-slim`	Start with Node.js 24 (base OS + runtime)
`WORKDIR /app`	Create `/app` directory (where your app lives)
`RUN npm install -g some-app`	Install the application globally
`ENV PORT=3000`	Set an environment variable
`VOLUME ["/data"]`	Mark a directory for persistent storage
`CMD ["some-app", "start"]`	Default command to run

When Docker builds this, it creates layers. Layer 1 is Node.js. Layer 2 is the app. If you rebuild and only change the app, Docker reuses layer 1 from cache. It's fast.

Docker Compose: Orchestrating Containers

Real applications need more than just a Dockerfile. You need to:

Set environment variables
Mount persistent storage
Handle restarts
Configure networking

Docker Compose is a tool that manages all this. You write a compose.yaml file:

services:
  myapp:
    build: .
    restart: unless-stopped
    volumes:
      - app-data:/data
    environment:
      - PORT=3000

volumes:
  app-data:

This tells Docker:

Build the image from the Dockerfile in this directory
If the container crashes, restart it automatically
Mount persistent storage at /data (survives restarts)
Pass environment variables into the container

Compose is the orchestrator—it keeps your container running, manages storage, handles restarts.

Persistent State: Volumes and Data

Here's an important concept: containers are ephemeral by default. When you stop a container, any data stored inside it is lost.

This is actually a feature—it means containers are isolated and clean. But for applications that need to remember things (databases, agent configurations, user data), you need persistence.

Volumes are Docker's solution. A volume is a storage location outside the container that survives restarts. When you mount a volume in a container, it can read and write data that persists even after the container stops.

In your compose.yaml, you define volumes:

volumes:
  openclaw-workspace:

And then mount them in your container:

volumes:
  - openclaw-workspace:/workspace

This tells Docker: "Create a persistent storage called openclaw-workspace, and mount it at /workspace inside the container." When the container stops, the data stays. When you restart the container, it reconnects to the same volume and picks up where it left off.

This is how your agent remembers things between restarts.

Docker Hub: The Registry Pattern (Again)

Remember NPM Registry? Docker Hub follows the same pattern.

Docker Hub is a registry of pre-built container images. When you write FROM node:24-slim, Docker automatically downloads that image from Hub.

You can push your own images to Docker Hub:

docker build -t yourname/myapp:1.0 .
docker push yourname/myapp:1.0

Anyone in the world can then run your container:

docker run yourname/myapp:1.0

This is how applications are distributed in the modern world—not as source code, but as ready-to-run containers.

Install Docker

You need Docker Desktop running on your machine.

Windows (with WSL):

Download: https://docs.docker.com/desktop/setup/install/windows-install/
Run the installer. Keep "Use WSL 2 instead of Hyper-V" checked.
Reboot if prompted.
Launch Docker Desktop from the Start Menu.
In Docker Desktop: Settings → Resources → WSL Integration → enable Ubuntu.

macOS:

Download: https://docs.docker.com/desktop/setup/install/mac-install/ (choose your chip: Apple Silicon or Intel)
Open the .dmg and drag Docker to Applications.
Launch Docker from Applications.

Linux:
Follow your distribution's guide: https://docs.docker.com/engine/install/

Verify it's working:

docker run hello-world

You should see "Hello from Docker!" — you're good.

Why OpenClaw in a Container?

OpenClaw is an AI agent. It's autonomous. It thinks, decides, and takes actions without you telling it each step. You could run it directly on your machine, but here's the problem: an autonomous agent with full access to your system is dangerous.

If you give OpenClaw permission to access your file system, it could read, modify, or delete files. If you give it access to your email or social media, it could send messages on your behalf. If it misbehaves, or if there's a bug in its reasoning, it could compromise your data or damage your system.

You don't want an autonomous agent running freely with full system access. You want it contained.

A container provides a sandbox:

OpenClaw runs in an isolated environment. It can't access your file system, your other projects, or your personal data unless you explicitly give it permission.
If OpenClaw misbehaves or causes damage, it's confined to the container. Your system stays safe.
You control exactly what OpenClaw has access to (a specific folder, a specific API key, Discord) through configuration.
If something goes wrong, you destroy the container and start fresh. Your system is unaffected.

This is why containers are essential for running autonomous agents safely. Containers let you run powerful systems—agents, untrusted code, experimental software—without putting your data at risk.

OpenClaw in a container means: powerful, but bounded.

Create Your OpenClaw Project

Set up a working directory:

mkdir -p ~/projects/openclaw
cd ~/projects/openclaw

Create a Dockerfile:

cat > Dockerfile << 'EOF'
FROM node:24-slim

WORKDIR /openclaw

RUN npm install -g openclaw@latest

ENV OPENCLAW_WORKSPACE=/workspace

VOLUME ["/workspace"]

CMD ["openclaw", "onboard"]
EOF

What this does:

FROM node:24-slim — Start with Node.js 24
WORKDIR /openclaw — OpenClaw lives in /openclaw inside the container
RUN npm install -g openclaw@latest — Install OpenClaw via npm (happens once, at build)
ENV OPENCLAW_WORKSPACE=/workspace — Tell OpenClaw where to store config
VOLUME ["/workspace"] — Persistent storage—survives container restarts
CMD ["openclaw", "onboard"] — Default command: run onboarding

Create a compose.yaml:

cat > compose.yaml << 'EOF'
services:
  openclaw:
    build: .
    container_name: openclaw
    restart: unless-stopped
    volumes:
      - openclaw-workspace:/workspace
    environment:
      - OPENCLAW_WORKSPACE=/workspace
    stdin_open: true
    tty: true

volumes:
  openclaw-workspace:
EOF

What this does:

cat command — outputs text. The > redirects it to a file. The << 'EOF' means "read input until you see EOF"—so you can paste a multi-line block. If you mess up, press Ctrl+C to cancel.
build: . — Build from the Dockerfile
restart: unless-stopped — Keep the container always-on; auto-restart if it crashes
volumes: — Persistent storage for agent config and state
stdin_open: true and tty: true — Allow interactive terminal input during setup

How OpenClaw's State Persists

The key line is volumes: - openclaw-workspace:/workspace. This tells Docker: "Create a persistent storage volume called openclaw-workspace and mount it at /workspace inside the container."

When you run OpenClaw and it saves your configuration, memories, and state—that all goes into /workspace. Because it's mounted as a volume, it survives container restarts.

What this means in practice:

You run the gateway and chat with your agent. It learns things, stores memories.
You stop the container (Ctrl+C in the terminal).
You restart the container later with docker compose run --rm openclaw openclaw gateway run.
Your agent picks up exactly where it left off. All memories, config, state—intact.

The volume is persistent. The container is ephemeral. When you destroy the container and start a new one, they both connect to the same volume. Your agent's data is safe.

This is why you don't lose your agent's state when the container restarts or crashes.

Get API Keys

OpenClaw needs Claude to think. You need an Anthropic API key.

Go to https://console.anthropic.com and create an account
API Keys → Create Key → copy it
Billing → add $5+

The API is pay-per-use, separate from Claude.ai. $5 lasts a while for personal use with Haiku.

Set Up Discord

Your agent will chat remotely through Discord. Create a bot for it to control.

First, create a Discord server (if you don't have one already):

Open Discord (https://discord.com)
Click the + icon on the left sidebar
Create My Own → give it a name (e.g., "OpenClaw Test") → Create
You now have a private server where your agent will live

Create the bot:

Go to https://discord.com/developers/applications
New Application → name it (e.g., "OpenClaw") → Create
Left sidebar: Bot
Reset Token → copy the token (you won't see it again)
Privileged Gateway Intents → enable Message Content Intent → Save

Invite the bot to a server:

OAuth2 → URL Generator
Scopes: check bot
Permissions: check Send Messages, Read Message History, View Channels
Copy the URL → paste in browser → select your server → Authorize

You need a Discord server (even a private test one). Once the bot is in a server, you can DM it.

Build and Run Onboarding

In your terminal:

cd ~/projects/openclaw
docker compose build
docker compose run --rm openclaw openclaw onboard

The build takes a few minutes the first time. Docker is downloading Node.js and OpenClaw. After that it's cached.

The onboarding wizard will prompt you:

Prompt	Choose
Select channel	Discord (Bot API)
Discord bot token	Paste from Part 5
Anthropic auth method	Anthropic API key
API key	Paste from Part 4
Model	`claude-haiku-4-5-20251001`
Web search	DuckDuckGo
Install missing skill dependencies	Skip
Configure skills	Yes
API keys (Google, Notion, etc.)	No
Enable hooks	Select `session-memory`, skip rest
Hatch in Terminal	Yes

On the model: Haiku is fast and cheap—perfect for always-on. Switch to Sonnet later if needed.

On skills: Don't install community skills yet. Get basics working first.

Define Your Agent

After onboarding, you define who your agent is. When prompted:

You are my personal AI assistant. I'm based in [city]. I'm a [background] focused on [goals]. Be direct, skip filler. Help me stay on top of tasks, research, and projects.

This gets saved to SOUL.md in your persistent volume. Edit it anytime to change how the agent behaves.

Start the Gateway

The gateway is the key to your agent listening to Discord. Here's what it does:

Your agent needs to listen for messages. In Discord, messages come in. Your agent needs to respond. The gateway is the listening port—the connection between your agent and Discord. The agent is now listening to Discord 24/7. It receives messages, thinks, and responds.

Start Your Agent

If you've already started a container and want to run the gateway (or restart it), don't use docker compose run again—that would start a new container. Instead, open another terminal window and use docker exec to start the gateway in the existing container:

docker exec openclaw openclaw gateway run

This runs the gateway in the container that's already running, without creating a duplicate.

You should see:

[gateway] loading configuration...
[gateway] resolving authentication...
[gateway] connected

Your agent should now be live on Discord. Tag it and send it a message in the Discord channel it's in. It will respond.

Leave this terminal open. Your agent stays connected as long as this process runs.

Having trouble getting the gateway set up or navigating terminals? You can insist OpenClaw do it for you -- and it can do it.

The Power and Danger of Agents

Here's something important: your agent has direct access to its integrations. When you gave it your Discord bot token and your API key, you gave it authority to act on your behalf.

This is powerful. Your agent can:

Set up its own Discord channels
Create reminders, manage tasks
Fetch and analyze data
Take actions autonomously

But be careful. An agent with access to your API keys and authentication tokens can do a lot. If you give it permission to access your email, it can read and send emails. If you give it access to your file system, it can read and modify files.

This is why agents need isolation (containers) and why you should audit what permissions you grant them.

For now, you've only given OpenClaw access to Discord and the Anthropic API. That's safe.

You've Deployed a Production System

You now have:

A containerized application — OpenClaw runs in an isolated container
Persistent storage — Configuration and state survive restarts
Automatic restarts — If the agent crashes, the container restarts it
Always-on operation — The gateway keeps your agent listening 24/7
Infrastructure as code — Your Dockerfile and compose.yaml document everything

This is real deployment. The same architecture scales to multiple agents, multiple servers, millions of interactions.

You've moved from learning tools to building systems.

Daily Use: Running Your Agent

Each time you start your machine, to start your agent:

cd ~/projects/openclaw
docker compose run --rm openclaw openclaw gateway run

Leave that terminal open. Open a new tab for other work.

macOS: Auto-Start on Login (Optional)

To start your agent automatically when your Mac boots:

mkdir -p ~/Library/LaunchAgents
cat > ~/Library/LaunchAgents/ai.openclaw.gateway.plist << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>ai.openclaw.gateway</string>
  <key>ProgramArguments</key>
  <array>
    <string>/usr/local/bin/docker</string>
    <string>compose</string>
    <string>-f</string>
    <string>/Users/YOUR_USERNAME/projects/openclaw/compose.yaml</string>
    <string>run</string>
    <string>--rm</string>
    <string>openclaw</string>
    <string>openclaw</string>
    <string>gateway</string>
    <string>run</string>
  </array>
  <key>RunAtLoad</key>
  <true/>
  <key>KeepAlive</key>
  <true/>
</dict>
</plist>
EOF

Replace YOUR_USERNAME with your Mac username. Then:

launchctl load ~/Library/LaunchAgents/ai.openclaw.gateway.plist

To disable: launchctl unload ~/Library/LaunchAgents/ai.openclaw.gateway.plist

Troubleshooting

Problem	Fix
`docker: command not found`	Docker Desktop isn't running. Launch it.
`openclaw: command not found`	Expected—it's inside Docker. Use `docker compose run`.
Gateway says "Missing config"	Config wasn't saved. Re-run: `docker compose run --rm openclaw openclaw onboard`
Discord bot not responding	Check Message Content Intent is enabled in Discord Developer Portal.
Onboarding starts fresh every time	Workspace volume isn't being used. Verify `ENV OPENCLAW_WORKSPACE=/workspace` in Dockerfile and rebuild.
(Windows WSL) Docker can't find files	Keep files in WSL home (`~/`), not Windows side (`/mnt/c/`).
(macOS Apple Silicon) "Architecture" warnings	Normal—emulated via Rosetta. Performance is fine.

Sources / additional material:

https://docs.docker.com/ — Docker official documentation

https://docs.docker.com/get-started/ — Docker getting started

https://docs.docker.com/compose/ — Docker Compose

https://hub.docker.com/ — Docker Hub registry

https://github.com/openclaw/openclaw — OpenClaw repository

https://console.anthropic.com — Anthropic Console

https://discord.com/developers/applications — Discord Developer Portal

This article was generated with AI for the purpose of providing practical information. I have reviewed it and edited it appropriately.

All About AI & Using Claude

Phillip A. Wessels — Tue, 26 May 2026 22:35:25 +0000

AI tools are fundamentally changing what developers can build -- and who can be a developer.

Large Language Models (LLMs) and AI are no longer science fiction. They're tools in your hands, right now. But like any powerful tool, they require understanding: what they are, how to use them, and what their limitations are.

This isn't about becoming an AI expert. It's about understanding the landscape, recognizing the tools available to you, and learning to work with them effectively. By the end of this article, you'll understand LLMs, the Claude ecosystem, and how to start using these tools in your workflow.

What is Machine Learning?

Machine Learning (ML) is the field where computers learn patterns from data instead of being explicitly programmed.

Traditional programming: You write rules. The computer follows them.

if temperature > 80:
    turn on AC

Machine Learning: You show the computer examples. It learns the pattern.
Input: temperature readings + AC on/off history
Output: Model learns to predict when AC should be on

The computer doesn't have explicit rules; it's learned patterns from data. This is powerful because patterns are everywhere, and humans can't always articulate them. Machine Learning finds them automatically.

What are Large Language Models?

A Large Language Model (LLM) is a type of AI trained on vast amounts of text data to predict and generate language.

Here's the core idea: LLMs learned by reading billions of examples of human language. They've internalized patterns about how language works—not consciously, but as mathematical patterns. When you ask them a question, they predict what text should come next, word by word, based on those patterns.

Key insight: LLMs don't "understand" in the way humans do. They're incredibly good at pattern recognition and prediction. But that pattern recognition is so sophisticated that it produces surprisingly intelligent output.

Think of it like this: If you've read thousands of novels, you can predict what comes next in a story. You've internalized patterns. LLMs have done this with vastly more data and mathematical precision.

How Do LLMs Actually Work?

You don't need to understand the mathematics. But here's the conceptual flow:

Training — The model reads billions of words from the internet, books, code, etc.
Pattern learning — It learns statistical patterns about language (what words follow other words, how to structure responses, etc.)
Your prompt — You ask it a question
Prediction — The model predicts what text should come next, one word at a time
Output — Those predicted words form your answer

Key concept: Tokens

LLMs work with "tokens"—small pieces of text (usually a few characters). When you write a prompt, it's converted to tokens. When you use an LLM, you pay based on tokens (input tokens + output tokens).

This matters because longer prompts cost more longer responses cost more.

A Brief History: How We Got Here

Year	Milestone
2012	Deep learning emerges as a powerful ML technique
2017	Transformer architecture invented (the foundation for all modern LLMs)
2018	BERT and GPT-1 launched (early language models)
2020	GPT-3 (OpenAI) shocks the world with its capabilities
2022	ChatGPT launches, bringing AI to the mainstream
2023	Claude 1 (Anthropic), GPT-4, Gemini, and others compete
2024–2026	Frontier models become faster, cheaper, more capable

The arc: models got bigger (more parameters, more training data) and better at following instructions. AI went from research novelty to practical tool.

Frontier Models

"Frontier models" just means the newest, most capable ones — the cutting edge.

Model	Who Makes It	Best For
Claude Opus 4.7	Anthropic	The writer and coder. Produces the most natural-sounding writing and is a favorite among software developers.
GPT-5.5	OpenAI (makers of ChatGPT)	The reliable all-rounder. Great default choice if you want one tool that does a bit of everything well. Has the biggest ecosystem of apps and add-ons.
Gemini 3.1 Pro	Google	The brainiac. Especially strong at science and logic questions, and works smoothly with Google apps like Docs and Gmail.
Grok 4.3	xAI (Elon Musk's company)	The deep thinker. Aimed at really hard, expert-level questions.
DeepSeek V4	DeepSeek (China)	The budget champion. Very cheap to use, which matters a lot for businesses.
Kimi K2.6 / GLM-5.1 / Qwen 3.7	Various (mostly China)	"Open" models you can download and run yourself. Increasingly competitive with the big closed ones.

Snapshot as of May 2026.

This field moves fast — new models launch almost every week, and today's leader can be overtaken in a month. Don't stress about always having the "best" one. Pick something that works for you, and know that they're all improving constantly.

Open vs. closed

"Closed" models (like GPT-5.5) live on the company's servers — you rent access. "Open-weight" models can be downloaded and run on your own computer or servers, which appeals to businesses and tinkerers.

Business Models & Pricing

These companies mostly earn money two ways: monthly subscriptions for everyday people, and pay-as-you-go API access for businesses building their own apps. As a beginner, you only care about the first one.

The good news: nearly everyone has settled on the same simple ladder.

Tier	Price	What you get
Free	$0	Real access to a capable model, with daily/weekly limits. Fine for trying things out.
Standard (Plus/Pro)	~$20/month	The sweet spot. ChatGPT Plus, Claude Pro, and Google AI Pro all land at roughly $20 and unlock the flagship models plus higher limits.
Premium / Max	$100–$250/month	For heavy daily users and professionals — much higher usage and extra perks like video generation. Most people don't need this.

A few helpful notes:

The big three all cost about the same at the $20 tier, so price isn't really the deciding factor — pick based on which one you like using.
Free tiers are genuinely good now. Start there before paying for anything.
Subscriptions stack up fast. Paying for ChatGPT and Claude and Gemini runs ~$60/month. Most beginners are happiest picking just one.
"API pricing" (those "$15 per million tokens" numbers) is for developers building software.

Tip: Try the free tiers of two or three for a week, then pay for the single one that earned its place. If you find yourself needing extra usage, consider upgrading your plan.

Cheaper/Free Alternatives

The $20/month flagship plans aren't your only option. If cost matters, here are three ways to spend less — roughly from easiest to most technical.

Smaller models from the same companies. Every big provider makes "mini" versions of their flagship — faster, cheaper, and still very capable for everyday tasks. Think Claude Haiku, GPT mini-tier, and Gemini Flash. They handle routine writing, summarizing, and Q&A at a tiny fraction of the flagship cost, and you'll often find them in the free tiers of the chat apps. For most casual use, these are plenty.
Third-party "model hosting" providers. Companies like Nebius, Together.ai, Groq, DeepInfra, and OpenRouter don't build their own models — they run open-source ones (Llama, Qwen, DeepSeek, and others) for you, usually much cheaper per use than the big labs. Note: these are mainly aimed at developers building apps, not casual chatbot users.

| Provider | Specialty | Best for |
|---|---|---|
| Groq | Speed | Ultra-fast inference |
| DeepInfra | Cost | Cheapest rates |
| OpenRouter | Flexibility | Switching between many models through one account |
| Nebius | Privacy | Running inside Europe (data-privacy compliant) |
| Together.ai | Open-source models | Building with Llama, Qwen, DeepSeek, and others |

Local models — run AI on your own computer. Free tools like Ollama and LM Studio let you download an open model (Llama, Gemma, Qwen, and similar) and run it entirely on your own machine. The upsides: it's free after setup, works offline, and nothing you type leaves your computer — great for privacy. The catches: you need a reasonably powerful computer, and these smaller local models aren't as sharp as the cloud-based frontier ones.

Rule of thumb: Use a cheap "mini" model for everyday stuff, and only reach for an expensive flagship when a task is genuinely hard (tricky coding, deep reasoning, long documents). This "use the cheap one by default" approach is exactly how cost-conscious businesses keep their bills down.

What Are AI Agents?

An AI Agent is an AI system that can autonomously perform tasks by:

Understanding a goal
Breaking it into steps
Taking actions (reading files, running code, making API calls)
Observing results
Adjusting and trying again

Agent	Creator	Description
OpenClaw	Open-source	"Operator" agent for personal productivity and automation. Grew from a weekend prototype to GitHub's most-starred repository, with a big marketplace of community-made skills.
Hermes Agent	Nous Research	Learns your workflows over time. Markets itself as "the agent that grows with you" and recently surpassed OpenClaw as the most-used open-source agent by daily usage.
Claude Code	Anthropic	Coding agent; a developer favorite for real software work.
Codex CLI	OpenAI	OpenAI's command-line coding agent, in the same category as Claude Code.
GitHub Copilot	GitHub/OpenAI	AI pair programmer integrated into VS Code and other editors for coding assistance.
Cursor	Anysphere	An AI-powered code editor (built on VS Code) with AI woven into every keystroke.

Snapshot as of May 2026.

This field moves fast — new agents launch almost every week, and today's leader can be overtaken in a month. Don't stress about always having the "best" one. Pick something that works for you, and know that they're all improving constantly.

Basic Prompt Engineering

You don't need to be an expert, but understanding a few patterns helps you get better results from models.

Pattern 1: Be Clear About Your Goal

Bad:

Write something about Python

Good:

Write a beginner-friendly explanation of what Python lists are, with 2 code examples.

Specificity matters. The model can't read your mind.

Pattern 2: Provide Context

Bad:

Fix this code

Good:

I'm trying to read a CSV file and count rows. Here's my code:
[code]
It's giving an error: [error message]
What's wrong?

Context helps the model understand your actual problem.

Pattern 3: Ask for Structure

Bad:

Tell me about Docker

Good:

Explain Docker in these sections:
1. What problem does it solve?
2. How does it work conceptually?
3. What are the main concepts (images, containers, registries)?
4. Why is it useful for development?

Structure forces clarity on both sides.

Pattern 4: Use Examples

Bad:

Make this function better

Good:

I want this function to be more readable. Here's an example of the style I like:
[example of clean code in your preferred style]
Now improve this function using that style:
[your function]

Examples communicate your preferences better than words.

Risks and Guardrails

LLMs are powerful, but they have limitations and risks:

Hallucinations

Models sometimes generates plausible-sounding but incorrect information. It might cite sources that don't exist or state facts that are wrong. Always verify important information.

Outdated Information

A model's training data has a cutoff date. It doesn't know current events or recent changes. For up-to-date info, you need to provide context or use tools that can browse the web.

Biases

LLMs learn from human-generated text, which contains biases. Models are generally trained to be helpful and harmless, but biases can still appear. Be aware of this, especially for sensitive decisions.

Security & Privacy

Don't share passwords, API keys, or sensitive credentials in prompts
Don't assume your prompts are private (especially with free tiers)
Treat conversations with LLMs as you would emails to a colleague

Overreliance

An LLM is a tool, not a replacement for human judgment. For important decisions, use models to help think, not to make the decision.

The Claude Ecosystem

Claude (the model) is made by Anthropic, a company focused on building safe, reliable AI. When you use Claude, you're accessing their LLMs through various interfaces. I choose to start folks off with Claude because it's great for development -- and agency is about building your own tools.

Claude's Interfaces

Claude is available through different tools, and you'll choose based on your use case:

Tool	What It Is	Best For	Cost
Claude.ai (Web)	Chat interface in the browser — the classic way to use Claude	Writing, research, analysis, brainstorming, everyday Q&A	Free (with limits) / $20/mo Pro / $100–$200/mo Max
Claude Desktop (Mac/Windows)	Standalone app — same chat as web, plus houses Cowork mode	Same as web chat, but stays in your dock. Required for Cowork. Supports Dispatch (control from phone).	Same subscription — Free, Pro, or Max
Claude Cowork	Agentic mode inside Desktop — reads, writes, and organizes files on your computer	Non-technical "get stuff done" work: organizing folders, building spreadsheets/decks/reports, multi-step file tasks. No terminal needed.	Included with Pro ($20/mo), but heavy use burns tokens ~50–100× faster than chat — Max ($100/mo+) realistic for daily use
Claude Code (Terminal CLI)	Command-line coding agent in your terminal	Software engineering: writing, refactoring, debugging across multi-file codebases	Pro ($20/mo) minimum. Max ($100–$200/mo) for heavy use. Or pay-per-token via API.
Claude Code VS Code / JetBrains Extension	Native IDE extension — Claude Code inside your editor	Same coding tasks as CLI, but in a visual editor instead of raw terminal	Bundled with your Claude subscription or API key
Claude Design	AI-powered visual canvas inside claude.ai — describe what you want, get interactive prototypes	Prototypes, pitch decks, slides, one-pagers, UI mockups. Codebase-aware design systems. Hands off directly to Claude Code.	No separate cost — shares existing Pro/Max/Team/Enterprise usage (research preview)
Claude in Chrome (Beta)	Browser extension — Claude can see, click, navigate, and fill forms in Chrome	Automating repetitive browser tasks: data extraction, form filling, multi-site research. Pairs with Cowork.	Included with paid plans. Pro gets Haiku only; Max/Team/Enterprise can pick Sonnet or Opus.
Anthropic API	Pay-per-token developer API — build Claude into your own apps	Developers embedding Claude in products, automating pipelines, running batch jobs. Full control, no UI.	Haiku ~$0.80/$4 per 1M tokens, Sonnet $3/$15, Opus $15/$75. No monthly minimum.

Using Claude with Agents like OpenClaw

Starting June 15, 2026 Claude subscribers will get a separate monthly "Agent SDK credit" for third-party tools like OpenClaw. The official page is here: https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan

For a beginner on a Pro plan who just wants to try OpenClaw with Claude right now:

If you're before June 15, 2026 — the Agent SDK credit hasn't kicked in yet. Your options today are to set up a pay-as-you-go API key at console.anthropic.com. You load a small amount of credit (even $5–$10 is enough to experiment), generate an API key, and plug that into OpenClaw's settings. You only pay for what you use — no commitment, no second subscription.

Once June 15 hits — you can opt in to the $20/month Agent SDK credit from your Claude account, and OpenClaw will be able to authenticate through your subscription again. That $20 covers light use. If you burn through it mid-month, OpenClaw stops working until your next billing cycle (unless you enable overage billing, which charges API rates).

Practical advice for beginners:
Start with the API key approach even after June 15 — it's simpler to understand ("I put in $10, I use $10") and avoids surprises. Use Sonnet 4.6 as your model in OpenClaw, not Opus. It's 5× cheaper and handles most tasks just as well. Save Opus for things that genuinely need it.

And honestly, if you're brand new to OpenClaw and just want to see what agents can do with Claude, the cheapest first step is to try Claude Code in your terminal — it's already included with your Pro plan, no extra setup, and gives you a feel for agentic Claude before adding OpenClaw into the mix.

Understanding Claude Code (CLI)

Claude Code is a command-line interface that lets you use Claude directly from your terminal. It's designed for developers—Claude can read your code, suggest improvements, and even write and run code for you.

Why is this relevant?

You'll use Claude Code in your workflow
It's a practical example of how Claude integrates into development
It shows how agents work (Claude understands your goal, suggests code, runs it)
It bridges the gap between "Claude the AI" and "Claude the development tool"

Why Claude Code Matters for What's Next

When you learn Docker (next), you'll use it to containerize applications. When you learn OpenClaw, you'll use it to build autonomous agents. Both of these will interact with LLMs—potentially Claude.

Claude Code is your first hands-on experience with that integration: an AI that can read code, understand your intent, and take action.

Setting Up and Using Claude Code

Now let's get hands-on. Claude Code is a command-line tool that brings Claude into your terminal.

Prerequisites

Node.js 18+ installed (you learned about this in the NPM article)
A paid Claude subscription. Sign up for Claude Pro ($20/mo) or Max ($100–$200/mo) at claude.ai. The free tier doesn't include Claude Code.

Installtion

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

Launch

cd /path/to/your/project
claude

Now you can start conversing with Claude and working on files.

On first launch you'll be prompted to authenticate in your browser. Choose the "Claude App" option and sign in with your Claude.ai account. Your credentials get stored — you only do this once.

Help

Remember you can enter:

claude --help

You should see usage instructions. If you get "command not found," restart your terminal or check that npm installed it correctly.

Your First Claude Code Command

Create a simple project:

mkdir my-claude-project
cd my-claude-project

Ask Claude Code to create a file:

claude "Create a file called hello.txt with the text 'Hello, Claude!'"

Claude will:

Understand your request
Suggest an approach
Execute it
Show you the result

Congratulations—you've just used an AI agent from the command line.

More Examples

Generate a simple Node.js script:

claude "Write a Node.js script that reads a file and prints its contents"

Get help with your code:

claude "I have this function [paste code]. Why is it slow?"

Build something:

claude "Create a simple web server that responds with 'Hello World' on port 3000"

Claude Code is a tool that gets better with practice. The more specific your requests, the better the results.

You're Now at the Frontier

You've completed the Foundations of Digital Agency and stepped into the frontier of modern development. You understand:

Operating systems and terminals
Code editors and development environments
The command line and scripting
Package management and registries
Now: Large Language Models and AI tools

What's coming:

Docker — Containerization and reproducibility
OpenClaw & Agents — Building autonomous systems
Web Applications — Real-world development
Beyond: Building your own solutions with AI as a partner

You now have the knowledge and the tools to claim agency. Not because you understand everything—nobody does. But because you understand enough to navigate, experiment, learn, and build.

Sources / additional material:

https://console.anthropic.com — Claude API Console

https://claude.ai — Claude web interface

https://code.claude.com — Claude Code documentation

https://www.anthropic.com/research — Anthropic's research on AI safety

https://openai.com/index/gpt-4/ — GPT-4 information

https://ai.google.dev/ — Google's AI tools

This article was generated with AI for the purpose of providing practical information. I have reviewed it and edited it appropriately.

On the Shoulders of Giants: Package Registries, Node & NPM

Phillip A. Wessels — Tue, 26 May 2026 22:35:18 +0000

You've mastered the command line. You understand your operating system and your development environment. Now it's time to learn how modern developers leverage the work of others: through packages, registries, and package managers.

Everything that comes next—Claude Code, Docker, OpenClaw, web applications—builds on the concepts you're about to learn. And at the center of all of it is a simple idea: reusable code, stored in a central place, installed with a single command. This is where we leverage the power of the Internet and begin to see the open-source community come into play.

Let's start with the why, then move to the how.

What is a Package?

A package (also called a module or library) is a collection of reusable code that someone else wrote, tested, and shared. Instead of writing authentication from scratch, you install a package that handles it. Instead of building a web server from the ground up, you install a package that does it for you.

Packages can be:

Small utilities: A function that formats dates, validates emails, or parses JSON
Large frameworks: Complete systems for building web applications, managing databases, or running AI agents
Tools and CLIs: Command-line applications you run directly

What Problem Do Registries Solve?

Before registries, developers had to email code to each other, host code on personal websites, track versions manually, and hope dependencies didn't break. A registry is a centralized, organized library where developers can publis* packages and others can install them. Think of it like an app store, but for code.

The most famous registry nowadays is the NPM Registry—the default home for JavaScript/Node.js packages. But the pattern appears everywhere:

Docker Hub — Registry for container images
PyPI — Registry for Python packages
ClawHub — Registry for OpenClaw AI agent configurations

What About GitHub?

GitHub isn't a registry for packages, but it plays a similar role and is crucial in the ecosystem: it’s a code repository hosting platform (one of several) where developers store their source code using Git version control. Most open-source packages (NPM, Docker, etc.) have their source code hosted on GitHub. Developers also collaborate on code through GitHub. And, while you can also install packages directly from GitHub repos (npm install github:username/repo), you'll also be able to clone many GitHub code repositories that are not packages, such as apps and projects. Like package registries, it's a vital way to build on the success of others.

How Registries Work

Here's the flow:

Developer writes code (e.g., a useful function)
Developer publishes to registry with a version number and metadata
You install from registry with a single command: npm install package-name
Registry delivers the code to your project
You use the code in your application

That's it. The registry is the middleman—a trusted place where packages live, versions are tracked, and installation is automatic.

Risks You Need to Know

Registries are powerful, but they come with responsibilities:

1. Security Vulnerabilities
Packages can have bugs or security holes. A popular package with a vulnerability could affect thousands of projects. Always:

Keep packages updated (npm update)
Check package reputation before installing
Use npm audit to find known vulnerabilities

2. Unmaintained Packages
A developer might stop maintaining a package. If it breaks or has a security issue, you're on your own. Check:

When was the last update?
Is the repository active?
How many people use it? (Popular = more eyes, more fixes)

3. Breaking Changes
New versions of packages might not work with your code. A seemingly small update could break your entire application. This is why versioning matters (we'll cover this below).

4. Supply Chain Risk
If you install 10 packages, and each installs 5 more, you're now depending on 50+ packages. One vulnerability in any of them affects you. Be intentional about what you install.

Further down we'll cover how to audit your packages.

How Packages Are Versioned

Packages use semantic versioning (semver): MAJOR.MINOR.PATCH

Example: 1.2.3

1 (major) — Breaking changes. Code might not work.
2 (minor) — New features, but backwards compatible.
3 (patch) — Bug fixes only, always safe.

When you install a package, you specify which versions you're willing to accept:

1.2.3 — Exactly this version
^1.2.3 — Any version up to 2.0.0 (minor and patch updates okay)
~1.2.3 — Any version up to 1.3.0 (patch updates only)
* or latest — Always the newest (risky!)

Your package.json file tracks this, ensuring your project stays reproducible.

What is Node.js?

JavaScript is one of the most accessible and widely-used programming languages. It's forgiving and relatively easy to learn. For decades, it only ran in browsers. Then Node.js arrived in 2009. Node.js is a JavaScript runtime environment. It lets you run JavaScript on your computer, on servers, and in development tools.

This means you can write or download JavaScript scripts and applications that run on your machine -- some as CLIs.

Result: NPM (Node Package Manager) is now the largest package registry in the world (over 2 million packages). JavaScript developers could write reusable code once and share it. That accessibility cascaded into an ecosystem. This is why you'll see Node.js/JavaScript everywhere in development tools—from build systems to CLI tools to web servers.

Installing Node.js and NPM

Node.js and NPM come together. When you install Node.js, you automatically get NPM.

Download and install nvm:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash

In lieu of restarting the shell:

\. "$HOME/.nvm/nvm.sh"

Download and install Node.js:

nvm install 24

Verify the Node.js version:

node -v # Should print "v24.16.0".

Verify npm version:

npm -v # Should print "11.13.0".

The above works on WSL and macOS (even though it says bash). However, the version numbers above may become outdated; refer to the page below for the current version.

https://nodejs.org/en/download

Creating a Project: `npm init`

We're not quite getting into projects yet, but when you start a new project, you initialize it with NPM:

mkdir my-project
cd my-project
npm init

NPM asks questions about your project (name, description, author, etc.). Answer them or press Enter to accept defaults. This creates package.json — the most important file in your project.

Understanding package.json

package.json is the contract for your project. It tells others (and future you):

What your project is
What dependencies it needs
What scripts it can run
What version it is

Example:

{
  "name": "my-project",
  "version": "1.0.0",
  "description": "My awesome project",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "build": "echo Building...",
    "test": "echo Running tests..."
  },
  "dependencies": {
    "express": "^4.18.0",
    "axios": "^1.4.0"
  },
  "devDependencies": {
    "nodemon": "^2.0.20"
  }
}

Key sections:

scripts — Commands you can run (npm start, npm run build)
dependencies — Packages your project needs to run
devDependencies — Packages you only need during development (testing, build tools, etc.)

Installing Packages

Install a package with:

npm install express

This:

Downloads express from NPM Registry
Adds it to dependencies in package.json
Creates node_modules/ folder (contains the actual code)
Creates package-lock.json (locks exact versions for reproducibility)

Install a development-only package:

npm install --save-dev nodemon

This adds it to devDependencies instead.

Understanding node_modules

When you install packages, NPM creates a node_modules/ folder. This folder contains:

The package you installed
All of its dependencies
All of their dependencies
And so on...

It can get HUGE (hundreds of MB).

Always commit package.json and package-lock.json to Git.
Never commit node_modules/ — it's too large, so it should be in your .gitignore.
When someone clones your project, they run npm install and it rebuilds node_modules from package.json.

Updating Packages

Check for outdated packages:

npm outdated

Update packages to their latest versions (respecting semver rules):

npm update

Update a specific package:

npm install express@latest

Caution: Updating can introduce breaking changes. Always test after updating, and commit your work first so you can revert if needed.

Running Scripts

You define scripts in package.json:

"scripts": {
  "start": "node index.js",
  "dev": "nodemon index.js",
  "build": "webpack",
  "test": "jest"
}

Run them with:

npm start
npm run dev
npm run build
npm test

Scripts are shortcuts. npm start is the same as running the command specified. This is why they're powerful—you can hide complex commands behind simple names.

How Can I Audit My Packages for Security/Bugs?

Security vulnerabilities in packages are inevitable. The good news: tools exist to help you manage them.

Manual audits with npm CLI:

When you're working in your project locally, you can run npm audit to check for known vulnerabilities in your packages. It scans against a database of known issues and suggests fixes. This is a manual check you do when you remember to do it.

Continuous monitoring (future):

When you later learn about version control with GitHub, you'll discover a tool called Dependabot that works alongside your package manager. Here's the idea:

Your package manager (NPM) handles installation and updates
Your code hosting platform (GitHub) can monitor your packages continuously
Dependabot automatically scans for vulnerabilities, notifies you of issues, and suggests updates
It never sleeps—it's checking your dependencies while you work on other things

This is an example of how tools in the ecosystem work together: one tool for packages, another for monitoring. You'll see this pattern throughout development—specialized tools doing specific jobs, all integrated together.

For now: Just know that security monitoring exists and is important. When you start working with version control and GitHub, you'll see how these tools connect.

Tools Worth Knowing About

nvm — Node Version Manager

nvm install 18
nvm use 18

Manage multiple Node.js versions. Useful when different projects need different versions.

npx — Run packages without installing globally

npx create-react-app my-app

Downloads and runs a package once, without installing it permanently. Great for one-off tools and generators.

Yarn — Alternative to NPM

yarn install
yarn add express

Different package manager with similar features. Some developers prefer it. For now, stick with NPM—they work the same way conceptually.

Registries: A Pattern You'll See Everywhere

Here's the crucial connection:

NPM Registry is a registry of packages (JavaScript code).

Docker Hub is a registry of images (containerized applications).

ClawHub is a registry of AI skills for OpenClaw.

The pattern is identical:

Someone creates something useful
They publish it to a registry with metadata and versioning
You install it with a command
You use it in your work

You now understand:

What packages are and why they matter
How registries work as central libraries
The risks and how to manage them
How to use NPM and manage dependencies
That this pattern repeats everywhere

Next we'll get into AI.

Sources / additional material:

https://docs.npmjs.com/

https://nodejs.org/en/docs/

https://docs.npmjs.com/cli/v9/configuring-npm/package-json

https://semver.org/ — Semantic Versioning specification

https://docs.npmjs.com/downloading-and-installing-packages-locally

This article was generated with AI for the purpose of providing practical information. I have reviewed it and edited it appropriately.

Commanding the Command Line

Phillip A. Wessels — Tue, 26 May 2026 09:13:59 +0000

You may experience some emotions of trepidation when staring at the empty prompt in the terminal.

That is very normal for beginners. But I want you to rewrite the story you're telling yourself from:

❌ I am going to mess something up with this.

to:

🚀 I am going to take off with this.

The command line does have deep functionality -- but it also has basics, and they're not complicated. By the time you finish this article, you'll understand those basics, and you can start to find your flow in the command line. Now let's get into:

Bash (your shell if you're on Windows or Linux)
Zsh (your shell if you're on macOS)

Either way, in the VS Code integrated terminal!

What does the command line do?

The command line allows you to interact with the operating system through the shell in your terminal.

Why use the command line interface (CLI) instead of a graphical user interface (GUI)?

It gives more control. There are things you can only do via the command line.
Because typing is fast and you can also automate tasks, the command line is far quicker; the small gains in speed per task cumulate into a significant amount of efficiency.
Compatibility; the command line will run on any machine, though Windows requires additional setup if you want to use the Unix command line. Cloud computing often requires the use of the command line. And, some AI tools are only available as CLIs.

What am I looking at?

The first thing you see is the prompt. The default composition of the prompt is as follows:

currentuser@hostname:workingdirectoryUID

Your prompt should look something like this if on WSL:

your-name@machine-name:/mnt/c/Users/your-name$

And not much different on macOS:

your-name@machine-name ~ %

What's `$`/`%`/`#` mean in the prompt? What's `sudo`?

Before we go any further we have to talk about privileges.

The prompt has a UID indicator to remind you if your privileges are standard ($ - Bash; % - Zsh) or root (#). Root is not recommended. Anyone accessing your workstation (digitally or physically) could take advantage of or sabotage your system. If you see # in the prompt, you should take it as a red flag.

With standard privileges ($/%), you can temporarily gain administrative privileges by using the sudo command. sudo ("soo doo", short for "substitute user do") will prompt you for your user password, then for 5 minutes the Linux environment will run any command-line with the root privileges (in other words, all privileges). If you need to use sudo for a command, you will receive a message stating something like "Permission denied."

Remember to store passwords securely.
http://pawper.dev/l/guide-password-management-cybersecurity-beginners

What's `~`? Where am I?

Your prompt shows the absoltue path from the root directory.

Think of a path as instructions for how to navigate the file system. Every / (Bash/Zsh's path separator) is a going from a directory into one of its contents. If you've spent time on Windows, you may be used to \ as the path separator, but you probably recognize / as a path separator from URLs on the Internet.

A path is an absolute path if it gives directions all the way from the root (the other kind of path is a relative path, but we'll return to that in a bit).

If you're in what's called the home directory for your user profile, you'll see ~. In Bash/Zsh, home is represented by the metacharacter ~, and if you use it in the CLI, the shell just sees it as the absolute path of your home directory. So you can always return home by entering cd ~! No ruby slippers required.

If you're using WSL and in the mounted Windows filestystem, you'll see something like /mnt/c/Users/your-name in the prompt. You should use cd ~ to change to your home directory in Linux. Stay on the Linux side of the fence!

What do I type here?

You can submit a command-line from the prompt. The general syntax is:

command -options arguments

Letter options follow a single dash and can be combined. For example, -lh. Word options follow two dashes, such as --help. Try the following commands as we go through them.

Some commands are just a command/utility name, such as clear.

clear

Others take arguments:

echo hello

Others accept letter options. Letter options are prefixed with a dash (-)

ncal -3hMj

Some options might be longform word options (--) and can't be combined in the above way.

df --human-readable --total --type=ext4

If you want to learn what options and arguments a command takes, use the --help option:

clear --help

Help, `--help` isn't working!

Enter:

history --help

You'll see it doesn't work.

If the option --help doesn’t work, it’s a built-in. Built-ins like history are built into the shell (Bash/Zsh) and aren’t a standalone application executed from a file. They are processed faster and have a slightly different way of getting help & usage. Try passing them to other commands, like:

help history
info history
man history

You can determine if a command is a builtin or external program using the type command:

type help
type history
type type

How do I navigate the filesystem?

When typing in the prompt, you can use absolute paths, but you'll usually use relative paths. Relative paths begin at the current directory, represented by ..

You can type .. in the path to indicate a parent directory. So, cd ../../.. goes up 3 times in the filesystem.

Note that Bash/Zsh are case-sensitive, and you'll need quotes around any paths with spaces in them.

Understanding the Root Directory

You can start using cd .. now to change directory up, but you should know -- The root directory (represented as /) is the top-level of your entire filesystem—the foundation from which all other directories branch out. It contains system files, configuration, and installed software that makes your operating system run. You'll rarely need to navigate here for your own work, but understanding what's there helps you navigate confidently and avoid dangerous mistakes.

⚠️ Caution: Never delete or modify files in the root directory or its subdirectories unless you know exactly what you're doing. One wrong command with rm can break your entire system. Always stay in your home directory (~) for your work.

Commands for Navigating & Working with the Filesystem

Command	Description
`pwd`	Print the working directory (where you are)
`mkdir -p path`	Create directories in the path(s) within the working directory
`cd path`	Change to the home directory (or specified path)
`ls path`	List the content of the working directory (or path)
`file file`	Print what kind of file it is
`mv source destination`	Move `source` to `destination`; also used to rename files (e.g., `mv old.txt new.txt`)
`ln -s path link`	Create a symbolic link (nickname) for a file or directory
`cp file1 file2`	Create a copy of `file1` named `file2`
`rm file`	Remove the file; use `-r` to remove directories recursively. ⚠️ No undo!
`locate x`	Search for `x` in the shell’s filesystem database
`updatedb`	Update the database that `locate` uses
`pushd` / `popd`	Save your location (`pushd`); return to it (`popd`)
`code .`	Open the current directory in VS Code

There is no undo. If you move, overwrite or delete a file or directory, it is a permanent change.

How do I make a new file?

Command	Use When
`touch filename.txt`	You need a quick empty file
`echo "content" > filename.txt`	You want to create a file with text in one command
`cat > filename.txt` then type content, Ctrl+D to save, Ctrl+C to cancel	You want to type content interactively
`code newfile.txt`	You want to create and edit in VS Code

Naming files

Capitalization matters and you should only use alphanumeric characters, hyphens and underscores. Other special characters cause issues, as they have special meaning to the operating system. Also avoid spaces because they are problematic; they do work if you put the filename in quotes ('my website').

Extensions

A file can have a file type that doesn't match its extension and files technically work without an extension (however this is not recommended). Use the file command to determine the actual file type.

How do I open / edit a file?

Command	Purpose
`code filename.txt`	Edit in VS Code — Best use this.
`cat filename.txt`	View file (read-only, printed to your terminal)
`less filename.txt`	Page through file (read-only) — View a file page-by-page. Space to scroll, B to go back, Q to quit.

If you accidentally end up in a terminal text editor like nano or vim:

Nano: Press Ctrl+X to exit (it will ask to save)

Vim: Press Esc, then type :q! (colon, q, exclamation) and press Enter to quit without saving

Helpful Notes

Bash is case-sensitive. Most of the time the command-line will be lowercase.
Use ↑ / ↓ to cycle through previous submissions.
You can enter a list of commands separated by ; or &&, all in one command line.
Enter !! (“bang bang”) to repeat the previous command line.
Right click with your mouse to paste.

Command Completion

If you start typing a command, directory or file name, you can use command completion (a.k.a. auto completion) with the Tab key to have the shell to guess where you are trying to get to. If it isn’t working because there are multiple possibilities, press Tab twice to see a list of conflicting files:

$ cd DoTab doesn’t autocomplete.

$ cd DoTabTab prints the conflicts:

Documents/ Downloads/

$ cd DocTab autocompletes to:

$ cd Documents/

WSL: converting Windows paths

wslpath is a CLI tool to convert Windows paths to Linux paths and vice-versa.

WSL users: Should you ever need to, you can open the current directory in Windows Explorer by entering explorer.exe .

Beyond the Basics (Optional)

Once you're comfortable with the fundamentals above, you can explore:

Pipes (|) — Chain commands together: cat file.txt | grep “search term” sends the output of one command into another
Redirection (>, >>) — Save output to files: ls > files.txt writes directory listing to a file; >> appends
grep — Search text: grep “pattern” filename finds lines matching a pattern
find — Advanced searching: find . -name “*.js” finds all JavaScript files recursively
sed / awk — Text processing and manipulation for advanced workflows

These tools unlock the real power of the command line, but they're not essential for getting started. Master the basics first, then explore these as you need them.

Permissions

You can see files’ permissions using the ls command with the long format argument (-l). They are represented within a string of characters and dashes at the beginning of a file’s line.

drwxr-xr-x 2 user user 4096 Jan  9 10:11 documents
-rw-r--r-- 1 user user  675 Jan  7 12:05 .profile

The first character indicates if the file is a directory or file. A d indicates it is a directory. A - indicates it is a file and is not a directory. The next 9 characters are the permissions.
Every file or directory belongs to a user owner and a group owner. Then there are other people. Files can be readable (r), writeable (w) and/or executable (x) for each, in that order. If you see a - where one of these characters should be, that means the owner, group or public does not have that permission.
chmod changes the mode/permissions of a file. You can optionally specify who for by using the corresponding letter for the owning user (u), owning group (g), and others (o). Use + to add a permission or - to remove it. Then follow that with the applicable permission(s): r, w and/or x. E.g., chmod +x file (adds executable permission for all) or chmod go-w file (removes write permission for the owning group and others).

Customize Your Prompt

When you open Bash/Zsh in VS Code, your prompt might look like:

user@computer:/path/to/project$

You can customize this by editing your .bashrc/.zshrc file (in your home directory):

code ~/.bashrc

Add this near the bottom to create a simpler, colorful prompt:

export PS1="\[\033[1;36m\]→\[\033[0m\] "

Or a prompt showing the current directory:

export PS1="\[\033[1;32m\]\w\[\033[0m\] \[\033[1;36m\]→\[\033[0m\] "

Save with Ctrl+s.

Reload your Bash configuration:

source ~/.bashrc

Prompt Key

Use these variables to build your custom prompt:

Variable	What It Shows	Recommendation
`\u`	Current username	✓ Keep it
`\h`	Hostname (computer name)	✓ Keep it (useful for Docker)
`\w`	Full path of current directory	Consider switching to `\W`
`\W`	Base name of current directory only	✓ Recommended (cleaner display)
`\@`	Current time (12-hour am/pm format)	Optional
`\$`	Shows `#` if root user, otherwise `$`	✓ Keep it (security indicator)

Color Codes

To customize colors, find where you want the color to change and insert: \[\033[X;Ym\] where X;Y is the color code below.

Example: \[\033[1;36m\]→\[\033[0m\] makes the arrow bright cyan.

Color	Code	Color	Code
Black	`0;30`	Dark Gray	`1;30`
Red	`0;31`	Light Red	`1;31`
Green	`0;32`	Light Green	`1;32`
Brown	`0;33`	Yellow	`1;33`
Blue	`0;34`	Light Blue	`1;34`
Purple	`0;35`	Light Purple	`1;35`
Cyan	`0;36`	Light Cyan	`1;36`
Light Gray	`0;37`	White	`1;37`

Note: Not all terminals support all colors. If using a terminal outside of VS Code, test and adjust if needed.

Troubleshooting

How to Escape Terminal Apps

If you're stuck in a terminal application (like a text editor, pager, or hung process), here are the universal ways to escape:

Keyboard Shortcut	What It Does
Ctrl+C	Interrupt/Cancel — Stops the current process. Works in most apps.
Ctrl+D	Exit — Signals end-of-file. Closes some apps like `cat` in input mode.
Q	Quit — Works in pagers like `less` and `man`. Just press Q.
Ctrl+Z	Suspend — Pauses the app and returns to prompt (type `fg` to resume, `bg` to run in background).
Esc then `:q!`	Vim exit — Press Esc, type `:q!`, press Enter to force-quit without saving.
Ctrl+X	Nano exit — Exits to prompt (asks if you want to save).

If nothing works: Try Ctrl+C first. If that hangs, try Ctrl+Z. In VS Code's terminal, you can also close the terminal tab directly.

Permissions Denied When Running Scripts

If you ever get a bash script, and you can't run it, use chmod +x:

chmod +x ./script.sh
./script.sh

The chmod +x command makes the script executable.

You are now in command of the command line. You can navigate the filesystem, manipulate files, run programs, and understand what's happening under the hood. That empty prompt that felt intimidating at the beginning? You know what to do with it now.

Sources / additional material:

https://code.visualstudio.com/docs/editor/command-line

This article was revised & expanded with AI for the purpose of providing practical information. I have reviewed it for accuracy and edited it appropriately.

Using the Terminal in VS Code

Phillip A. Wessels — Tue, 26 May 2026 09:12:03 +0000

VS Code is technically an editor, not a full IDE (Integrated Development Environment). Unlike IDEs like Visual Studio or JetBrains products that bundle everything together, VS Code starts minimal and lets you add what you need. But here's where it gets interesting: features like the integrated terminal, source control integration, debugging, and extensions blur that line significantly. By integrating tools into VS Code—especially the terminal—you're not adding bloat; you're building a customized developer experience tailored to your workflow.

This is the power of VS Code: you control what you integrate. In this tutorial, you'll learn to use the integrated terminal to run commands, build projects, commit code, and debug applications—turning VS Code into an environment that feels more like an IDE without the overhead. As covered in Part 1 of this series, understanding terminals and how they integrate into your workflow is foundational. Here, we'll make that integration practical.

Why Use the Terminal in VS Code?

Problem: Switching Between Windows

Without an integrated terminal, you're constantly:

Writing code in VS Code
Switching to Terminal to run commands
Switching back to VS Code to see the results
Repeating this loop hundreds of times per day

Context switching is awful for you. It's important that your developer experience is conducive to flow.

Solution: Integrated Terminal

VS Code's integrated terminal runs inside your editor. You can:

Run commands without leaving VS Code
See your code and terminal output at the same time
Execute build commands, run tests, and start development servers with a few keystrokes
Use the same terminal window for your entire development session

What Shell Should You Use?

The integrated terminal in VS Code can run any shell installed on your system. Your choice depends on your operating system and setup:

On Windows

Use bash (from Ubuntu through WSL). This gives you a Unix-based development environment that matches your production servers and aligns with most tutorials. If you haven't already, install WSL and configure VS Code to use it.

From here on we'll assume you're using Windows & VS Code with the Bash shell from WSL in your VS Code integrated terminal.

On macOS

Use zsh (default in modern macOS).

Setting Up the Integrated Terminal

Step 1: Open the Integrated Terminal

Open VS Code and press Ctrl+` (backtick, the key below Esc) to open the integrated terminal.

Alternatively, go to View → Terminal or right-click in the editor and select "Open in Integrated Terminal".

The terminal will open at the bottom of your editor.

Windows Users: Ensure VS Code is remote connected with WSL

By default on Windows, VS Code opens terminals in PowerShell. But if you have VS Code configured for WSL, the terminal should open with the Ubuntu (WSL) or Bash shell. If it opens to PowerShell, ensure VS Code is remote connected with WSL.

Step 2: Create a New Terminal

Close your current terminal (click the X) and open a new one with Ctrl+`.

Verify by running:

echo $SHELL

You should see /bin/bash (WSL) or /bin/zsh (macOS).

Using the Integrated Terminal

Basic Workflow

Now that your terminal is set up, here's how you'll use it:

Open a project folder: File → Open Folder, then select your project directory
Open the terminal: Ctrl+`
Run commands: Type whatever you need (npm install, git commit, etc.)
See output immediately: Right above your code in the same window

Multiple Terminals

You can open multiple terminal tabs within the integrated terminal:

New terminal: Click the + button in the terminal panel, or press Ctrl+Shift+`
Switch between terminals: Click the terminal name at the top, or use Ctrl+PageUp/PageDown to cycle through them
Split terminals: Click the split icon (or right-click and select "Split Terminal") to run two terminals side-by-side

This is useful for:

Running a development server in one terminal (npm start)
Running tests in another (npm test)
Having a third for git commands or other tasks

Terminal Shortcuts

Learn these keyboard shortcuts to work faster:

Shortcut	Action
Ctrl+`	Toggle terminal open/close
Ctrl+Shift+`	Create new terminal
Ctrl+PageUp	Previous terminal
Ctrl+PageDown	Next terminal
Ctrl+Shift+C	Copy selected text
Ctrl+Shift+V	Paste
Ctrl+Shift+W	Close terminal
Ctrl+Shift+Home	Clear terminal (or `clear` command)

Customizing Your Terminal

Change Terminal Font Size

In Settings (Ctrl+,), search "terminal font size":

"terminal.integrated.fontSize": 14

Change Terminal Font Family

"terminal.integrated.fontFamily": "Cascadia Code"

Popular options:

Cascadia Code (Microsoft's modern monospace font)
Fira Code (elegant, with ligatures)
JetBrains Mono (developer-focused)
Consolas (Windows built-in, simple)

Change Terminal Appearance

"terminal.integrated.colorScheme": "One Dark Pro",
"terminal.integrated.lineHeight": 1.5

Troubleshooting

"bash: command not found"

If bash isn't in your PATH, you need to specify the full path. In VS Code settings:

"terminal.integrated.defaultProfile.windows": "bash",
"terminal.integrated.profiles.windows": {
  "bash": {
    "path": "C:\\Windows\\System32\\bash.exe"
  }
}

Or simply use Ubuntu (WSL) as your default profile instead.

Terminal Opens in Wrong Directory

By default, the integrated terminal opens in your project root (where you opened the folder). If it opens elsewhere, you can force it:

"terminal.integrated.cwd": "${workspaceFolder}"

Terminal Text is Too Small or Too Large

Adjust in Settings (Ctrl+,):

"terminal.integrated.fontSize": 14

Try sizes between 12-18 depending on your monitor.

Sources / additional material:

https://code.visualstudio.com/docs/editor/integrated-terminal

https://code.visualstudio.com/docs/editor/command-line

https://github.com/microsoft/vscode/wiki/Terminal-Profiles

This article was generated with AI for the purpose of providing practical information. I have reviewed it and edited it appropriately.

Using VS Code with WSL

Phillip A. Wessels — Tue, 26 May 2026 09:06:33 +0000

Note: This guide is for Windows only. If you're on macOS, you are already living in Unix in VS Code, so you can skip this tutorial and move on to the next one in the series.

So, you're on Windows. You've installed VS Code, WSL and Windows Terminal per the previous entries in the series -- but here's the problem: your editor VS Code is a Windows application. As discussed in the last entry in the series, the world of modern web development assumes a Unix-based environment. You have WSL (Linux) -- so you're close! -- but if you don't configure VS Code properly, you'll be:

Editing files in Windows while tools run in Linux (file sync issues)
Running commands in the wrong environment
Dealing with path mismatches and permission problems
Losing the seamless development experience you're after

The solution is Remote - WSL, an extension that connects VS Code directly to your WSL environment. This tutorial shows you how to set it up.

What's Remote - WSL?

Remote - WSL is a Microsoft extension that lets VS Code run inside your WSL environment instead of Windows. Here's what that unlocks:

VS Code connects to WSL and runs there
You edit files in your Linux home directory (~/projects/...)
All commands run in the same Linux environment
Everything is unified and seamless

It's the missing link between your Windows editor and Linux development environment.

Why This Matters

Here's the key insight: you want to stay on one side of the fence. Don't straddle Windows and Linux simultaneously while developing. It's really for the best! And VS Code makes it easy.

When you configure VS Code to work with WSL, several things happen:

A Common Base Experience: Your terminal automatically opens bash, not PowerShell. This means instructions in future tutorials work identically whether you're on Windows or macOS. No need for special "Windows version" steps—you're developing in a Unix environment on both platforms.

Better Performance: Accessing files from your WSL home directory is faster than accessing Windows files through /mnt/c/. Keeping everything on the Linux side means no cross-filesystem overhead.

A Single Source of Truth: All your projects live in one place (WSL), one filesystem, one set of permissions. No confusion about whether you edited a file from Windows or WSL, no permission conflicts, no npm package installation weirdness.

The Foundation for What's Next: Later in this series, you'll use Docker to run projects in isolated containers. Docker extends this principle—your code runs in the same type of environment locally as it does in production. WSL is the first step: establishing that your local development happens in a Unix environment, not Windows.

So -- when you are working on a project, in most cases you'll live on the WSL side of the fence through VS Code. Don't be intimidated. You can do it!

Installing Remote - WSL

Step 1: Install the Extension

Open VS Code and install Remote - WSL (by Microsoft):

Press Ctrl+Shift+X to open Extensions
Search for "Remote - WSL"
Click the first result (official Microsoft extension)
Click Install

That's it. The extension will install in seconds.

Step 2: Verify Installation

Look at the bottom-left corner of VS Code. You should see a green button or icon indicating the remote connection status. If you see "WSL" or a green icon, the extension is active.

Opening a WSL Project Folder

Method 1: Open Folder from WSL

This is the most reliable way:

Open Windows Terminal and launch bash (which opens WSL)
Navigate to your project folder:

   cd ~/projects/my-project

Or create a new one:

   mkdir -p ~/projects/my-project
   cd ~/projects/my-project

Open VS Code from that directory:

   code .

VS Code will launch and automatically detect WSL. You'll see "WSL" in the bottom-left corner, confirming you're connected.

Method 2: Open Folder via VS Code UI

Open VS Code
Click File → Open Folder
Navigate to \\wsl$\Ubuntu\home\your-username\ (your WSL home)
Select your project folder
Click Select Folder

VS Code will connect to WSL automatically.

Method 3: Use the Remote Connection Button

Open VS Code
Click the green icon or button in the bottom-left corner
Select "Open Folder in WSL" or "Connect to WSL"
Select your project folder when prompted

Working Inside WSL

Once VS Code is connected to WSL, everything works in the Linux environment:

File Explorer

Your file explorer shows your WSL filesystem, not Windows:

/home/username/ is your home directory
/home/username/projects/ is where you keep projects
Paths use / not \

Terminal

When you open a terminal in VS Code (Ctrl+`), it opens bash in WSL, not PowerShell in Windows. This is perfect because all your tools (npm, git, node) are already here.

File Permissions

Files are created with proper Linux permissions. No more permission issues when switching between editors.

Verifying Your Environment

Open the terminal in VS Code (Ctrl+`) and verify you're in WSL:

echo $SHELL

Should show /bin/bash or /bin/zsh.

Check your location:

pwd

Should show /home/username/..., not C:\Users\....

Common Issues

VS Code Doesn't Show WSL Option

Make sure:

You've installed the Remote - WSL extension
You have WSL installed (run wsl --version in Windows Terminal)
You have a Linux distribution installed (like Ubuntu)
You've restarted VS Code after installing the extension

Can't Find Your Project Folder

Use \\wsl$\Ubuntu\ in the File → Open Folder dialog:

Click File → Open Folder
Type \\wsl$\Ubuntu\ in the address bar
Press Enter
Navigate to /home/your-username/
Select your project

Terminal Shows PowerShell Instead of Bash

Your VS Code terminal might still default to PowerShell. Change it:

Press Ctrl+, to open Settings
Search "terminal default profile"
Find Terminal › Integrated: Default Profile: Windows
Change to bash or Ubuntu (WSL)

Files Show as Modified Even Though You Didn't Change Them

This usually happens when you edit files from both Windows and WSL. To avoid it:

Always edit files inside VS Code connected to WSL
Don't edit the same files from Windows and WSL simultaneously
Use VS Code's WSL connection exclusively for development

Best Practice: Organize Your Projects in WSL

Create a dedicated projects directory in WSL and keep all your work there. You should do this directly via Bash in the terminal:

mkdir -p ~/projects/my-project
cd ~/projects/my-project
code .

Then always use code . from WSL to open projects in VS Code. This ensures VS Code always knows it's in WSL and everything stays in one environment.

What About Windows Files?

If you absolutely need to access Windows files (like Downloads), you can. They're mounted at /mnt/c/:

cd /mnt/c/Users/YourUsername/Downloads

But for development, keep projects in your WSL home directory. Performance and permissions are better there.

Sources / additional material:

https://code.visualstudio.com/docs/remote/remote-overview

https://code.visualstudio.com/docs/remote/wsl

https://code.visualstudio.com/docs/remote/wsl-tutorial

This article was generated with AI for the purpose of providing practical information. I have reviewed it and edited it appropriately.

Installing Terminal & WSL (Windows Subsystem for Linux)

Phillip A. Wessels — Sat, 23 May 2026 19:16:41 +0000

If you're a web developer on Windows, Windows Subsystem for Linux (WSL) is essential. This tutorial walks you through understanding what WSL is, why you should use it, and how to install and configure it for development.

Note: This guide is for Windows only. If you're on macOS, you already have a Unix-based terminal, so you can skip this tutorial and move on to the next one in the series.

Do I really need WSL?

Short answer: Yes, if you're doing web development on Windows.

Most web development tools, packages, and tutorials assume a Unix-based environment (Linux or macOS). While you can develop on Windows using PowerShell or cmd.exe, you'll constantly run into compatibility issues with package managers, build tools, and open-source projects that assume a Unix shell. WSL lets you run Linux directly on Windows without the overhead of a virtual machine.

What exactly is WSL?

Windows Subsystem for Linux (WSL) is a compatibility layer that allows you to run a genuine Linux environment directly on Windows. It runs a real Linux kernel in a lightweight virtual machine while remaining tightly integrated with Windows—you get the speed and compatibility of Linux with the convenience of Windows.

What's a Linux distribution (distro)?

A Linux distribution is a packaged version of the Linux kernel bundled with specific tools, package managers, and system utilities. Common distributions include Ubuntu, Debian, Fedora, and Alpine. For development, Ubuntu is the most beginner-friendly and widely supported choice.

Why WSL instead of dual-booting Linux?

Dual-booting lets you choose your OS at startup, but you can't use Windows and Linux simultaneously without rebooting. WSL gives you both environments running at the same time with seamless file access between them. You get the best of both worlds.

Why WSL instead of a virtual machine (VM)?

VMs use more system resources (CPU, RAM, storage) than WSL. WSL is lightweight, boots faster, and integrates better with Windows. If you're resource-constrained or want a quick development environment, WSL is superior.

Do I lose anything by using WSL?

WSL gives you a Linux shell and command-line tools, but it doesn't run a full graphical Linux desktop by default. You'll still use Windows for your GUI applications (VS Code, browsers, etc.) and access Linux through the terminal. This is exactly what most developers want.

💻 Install Windows Terminal (Recommended)

Windows Terminal is Microsoft's modern terminal application. Instead of using the default Windows PowerShell or cmd.exe, Windows Terminal provides a cleaner, more customizable experience with multiple tabs, themes, and seamless WSL integration.

What's a Terminal? As explained in FAQ: Operating Systems, Terminals & Shells, a terminal is the application that runs a shell (the command-line interpreter). Windows Terminal is the container app, while Bash/Zsh/PowerShell are the shells inside it. See that FAQ for deeper explanation.

Install from Microsoft Store:

Open the Microsoft Store (search "Microsoft Store" in the Windows Start menu)
Search for "Windows Terminal"
Click "Install"

That's it! Once installed, Windows Terminal is ready to use. You'll use it to run the WSL installation command in the next section. After WSL is installed, Windows Terminal will automatically recognize Ubuntu as an available shell profile.

💻 Install WSL

These instructions are for Windows 10 (Build 19041+) or Windows 11.

Step 1: Check Your Windows Version

Press Win + R, type winver, and press Enter. You need:

Windows 10: Version 21H2 or later (Build 19041 or higher)
Windows 11: Any version

If you need to update, go to Settings → System → About → Windows Update.

Step 2: Enable WSL

Open Windows Terminal as Administrator:

Right-click the Windows Terminal icon (in Start menu or taskbar)
Select "Run as Administrator"
You may see a prompt asking "Do you want to allow this app to make changes?" — click "Yes"

Once Windows Terminal opens with admin privileges, you'll see a command prompt. Regardless of which shell it displays (PowerShell, cmd.exe, or another), the wsl --install command works in any of them. Simply paste or type:

wsl --install

This single command will:

Enable WSL and the Virtual Machine Platform feature
Download and install Ubuntu (the default distro)
Automatically configure the latest version for you

Note: If you see an error about virtualization, you may need to enable it in your BIOS. Restart your computer, enter BIOS (usually by pressing F2, F10, DEL, or ESC during startup — varies by manufacturer), and look for "Virtualization" or "Intel VT-x" / "AMD-V" and enable it.

Step 3: Restart Your Computer

WSL requires a system restart. Do this now.

Step 4: Complete Ubuntu Setup

After restarting, Ubuntu may launch automatically, or you may need to launch it manually:

If Ubuntu launches automatically: You'll see a terminal window prompt you to create a username and password. Skip to the next section.

If Ubuntu doesn't launch automatically: Open Windows Terminal, click the dropdown arrow in the toolbar, and select "Ubuntu" to launch the setup.

Either way, you'll see a setup prompt:

Installing, this may take a few minutes...
Please create a default UNIX user account. The username does not need to match your Windows user name.
For more information visit: https://aka.ms/wsluserstore
Enter new UNIX username: [type your username]
New password: [type a password]
Retype new password: [confirm password]

Choose a simple username (e.g., dev or your first name). Remember this password — you'll need it for administrative tasks in WSL.

https://pawper.dev/?v=entry&cat=logs&entry=latest&modal=log&id=guide-password-management-cybersecurity-beginners

Step 5: Verify Installation

In the Ubuntu terminal that's now open, verify everything works:

wsl --version

You should see output showing WSL version 2.x.

Also verify your Linux distribution:

lsb_release -a

You should see Ubuntu information.

Sources / additional material:

https://docs.microsoft.com/en-us/windows/wsl/install

https://docs.microsoft.com/en-us/windows/wsl/about

https://docs.microsoft.com/en-us/windows/wsl/setup/environment

Step 6: Configure Windows Terminal for Ubuntu

Now that WSL and Ubuntu are installed, you can use Windows Terminal to access your Linux environment. Open Windows Terminal and you'll see a dropdown arrow in the top toolbar — click it and select "Ubuntu" to launch your WSL bash shell.

Set Ubuntu as Default (Optional): If you want Ubuntu to open automatically when you launch Windows Terminal, go to Settings (Ctrl+,), find "Startup" in the left sidebar, and set "Default profile" to "Ubuntu".

Configure WSL for Development

Update Your Linux Packages

WSL comes with Ubuntu, but the package lists may be outdated. Run:

sudo apt update
sudo apt upgrade -y

The sudo command runs commands with administrator privileges. You'll be prompted for your password (the one you created in Step 4).

Install Essential Build Tools

Most web development depends on a C/C++ compiler. Install it:

sudo apt install build-essential -y

This installs gcc, g++, make, and other tools needed to compile native packages.

(Optional) Install Git

If you don't have Git installed on your Windows machine, install it in WSL:

sudo apt install git -y

Note: You can use either the Windows version or WSL version of Git. I recommend installing it in both places so you have flexibility.

(Optional) Install Node.js (via nvm)

Many web tutorials use Node.js. The easiest way to manage Node versions is with nvm (Node Version Manager):

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Then reload your shell:

source ~/.bashrc

Install Node.js:

nvm install node

Verify:

node --version
npm --version

Access Your Files

WSL and Windows share a file system, but you need to know the paths:

From WSL, Access Windows Files

Your Windows C: drive is mounted at /mnt/c/ in WSL:

cd /mnt/c/Users/YourUsername/Documents

From Windows, Access WSL Files

Your WSL home directory is located at:

\\wsl$\Ubuntu\home\username<br>

Open File Explorer and type this path in the address bar. You can also open it with explorer.exe ~ from the WSL terminal.

Best Practice

Keep your development projects in WSL's home directory (~/projects/ or similar), not in Windows. This avoids file permission issues and improves performance.

Troubleshooting

WSL Doesn't Start / "Command Not Found"

Make sure you ran wsl --install in PowerShell as Administrator, not cmd.exe or a regular PowerShell window.

"Virtualization is not enabled"

You need to enable virtualization in your BIOS. Restart your computer, enter BIOS (varies by manufacturer), and look for "Virtualization" or "VT-x" / "AMD-V".

WSL Is Slow

This might mean you're accessing files across the Windows/WSL boundary. Keep your projects in WSL's home directory, not /mnt/c/.

Forgot Your WSL Password

In PowerShell, reset it with:

wsl --user root
passwd username

Then exit and log back in as your regular user.

Sources / additional material:

https://docs.microsoft.com/en-us/windows/wsl/install
https://docs.microsoft.com/en-us/windows/wsl/about
https://docs.microsoft.com/en-us/windows/wsl/setup/environment
https://docs.microsoft.com/en-us/windows/wsl/troubleshoot/common-issues
https://docs.microsoft.com/en-us/windows/wsl/setup/windows-terminal

This article was generated with AI for the purpose of providing practical information. I have reviewed it for accuracy and edited it appropriately.

Password Management & Cybersecurity for Beginners

Phillip A. Wessels — Sat, 23 May 2026 09:30:03 +0000

You don't need to be a security expert to protect yourself online. This guide covers the essential practices that will keep your accounts, code, and data safe.

The Reality of Online Security

Every day, millions of passwords are stolen, accounts are hacked, and sensitive data is exposed. The good news: most attacks aren't sophisticated. They succeed because people use weak passwords, reuse passwords across sites, or fall for social engineering. You can protect yourself with simple, consistent habits.

What's a Strong Password?

A strong password is:

Long (16+ characters is ideal, minimum 12)
Unique (never reuse the same password across sites)
Complex (mix of uppercase, lowercase, numbers, symbols: P@ssw0rd!Secure2024)
Unpredictable (not based on personal info like birthdays or pet names)

A weak password is:

Short (password, 123456)
Dictionary words (dragon, football)
Personal information (birthdate, spouse's name)
Patterns (qwerty, aaa111)

The problem: Remembering 50+ unique, complex passwords is impossible. This is where password managers come in.

What's a Password Manager?

A password manager is an application that securely stores all your passwords in an encrypted vault. You remember one master password, and the manager remembers the rest.

How it works:

You create one strong master password
The manager generates unique, complex passwords for each account
You log into the manager with your master password
The manager auto-fills passwords when you visit websites
Everything is encrypted — even the password manager company can't see your passwords

Popular options:

Bitwarden (open-source, free tier available, excellent for beginners)
1Password (premium, very user-friendly)
LastPass (free tier, widely used)
KeePass (free, offline, more technical)

I recommend Bitwarden for most people: it's free, open-source, and works across all devices.

Two-Factor Authentication (2FA)

Two-factor authentication means you need two things to log in:

Something you know (password)
Something you have (phone, security key, or authenticator app)

Even if someone steals your password, they can't access your account without the second factor.

Types of 2FA:

SMS / Text Message

A code is texted to your phone. Simple, but vulnerable to SIM swapping (hackers convince your phone company to transfer your number to their phone).

Authenticator Apps

Apps like Google Authenticator, Microsoft Authenticator, or Authy generate time-based codes on your phone. More secure than SMS.

Example code from authenticator: 482953 (changes every 30 seconds)

Security Keys

Physical devices (USB or wireless) that confirm login attempts. The most secure option.

Recommendation: Use authenticator apps for important accounts (email, GitHub, Stripe, AWS). Use SMS as a backup if authenticator isn't available.

Social Engineering Attacks

Social engineering is tricking people into revealing secrets or bypassing security. It's often easier than hacking.

Phishing

Attackers send emails that appear to be from trusted companies (your bank, GitHub, PayPal) asking you to "verify your account" or "confirm your identity."

Example phishing email:

From: security@paypal.com
Subject: Urgent: Confirm Your Identity

Your account has suspicious activity. Click here to verify:
paypal-security-verify.com/login

[FAKE LINK]

How to spot phishing:

Check the sender's email address carefully (paypal.com is real; paypal.security.com is fake)
Hover over links before clicking — see the actual URL
Legitimate companies never ask you to verify passwords via email
Look for poor grammar or urgent language ("Act now!" "Verify immediately!")
If in doubt, close the email and visit the company's website directly

Spoofs

A spoof is when someone pretends to be someone else (via email, phone, text). They might:

Send an email that appears to be from your boss asking to wire money
Call pretending to be from IT support asking for your password
Text as your bank asking you to confirm your account number

Golden rule: Never trust communication you didn't initiate.

If someone claims to be from your bank, GitHub, or any company:

Don't click links or call numbers in the message
Go to the official website directly (type the URL yourself or use a bookmark)
Log in and check for alerts in your account
Call the official phone number from the company's website (not from the email/text)

Example:

❌ You receive: Email from "GitHub" with link asking to verify your account
✅ What to do: Go to github.com directly, log in, check your security settings

Malware

Malware is malicious software that infects your computer. It can:

Steal passwords (keyloggers record everything you type)
Steal files and data
Hijack your browser
Lock your files for ransom (ransomware)

How to avoid malware:

Download software only from official sources (GitHub, npm, official websites)
Be cautious of email attachments (especially .exe, .zip, .bat files)
Keep your operating system and software updated
Use antivirus software (Windows Defender is built into Windows)
Don't run scripts or commands from untrusted sources

Developer-Specific Security

The Problem: Secrets in Code

Developers often need to store secrets like:

Database passwords
API keys (Stripe, OpenAI, AWS)
OAuth tokens
Authentication credentials

Never commit secrets to version control. If you push secrets to GitHub, they're exposed to the world — and attackers scan GitHub for exposed keys.

Example of what NOT to do:

// ❌ NEVER DO THIS
const apiKey = "sk-1234567890abcdefgh";
const dbPassword = "myPassword123";

The Solution: Environment Variables & .env Files

Store secrets in a .env file (local only, never committed):

Your .env file (local, never uploaded):

OPENAI_API_KEY=sk-1234567890abcdefgh
DATABASE_PASSWORD=mySecurePassword123
STRIPE_SECRET_KEY=sk_live_...

Your .gitignore file (tells Git to ignore the .env file):

.env
.env.local
.env.*.local

Your code (reads from environment variables):

const apiKey = process.env.OPENAI_API_KEY;
const dbPassword = process.env.DATABASE_PASSWORD;

How to Use .env Files

Create a .env file in your project root
Add your secrets: KEY=value
Add .env to .gitignore
In your code, read from process.env.KEY (Node.js) or process.env (most languages)
Never commit .env — only commit .env.example with placeholder values

Example .env.example (for documentation):

OPENAI_API_KEY=your-api-key-here
DATABASE_PASSWORD=your-password-here
STRIPE_SECRET_KEY=your-stripe-key-here

Tools for Managing Secrets

For production environments, use dedicated secret management tools:

AWS Secrets Manager — cloud-hosted secret storage
HashiCorp Vault — open-source secret management
GitHub Secrets — for CI/CD pipelines (Actions, etc.)
Vercel/Netlify Environment Variables — for serverless deployments

These are more secure than .env files for production.

Practical Security Checklist

For Your Personal Accounts

Use a password manager (Bitwarden, 1Password, or LastPass)
Create one strong master password and memorize it
Enable 2FA on critical accounts (email, GitHub, banking, social media)
Use authenticator apps instead of SMS when possible
Never click links in suspicious emails — visit websites directly
Never give passwords or 2FA codes to anyone, even "IT support"
Keep your OS and software updated
Use a VPN on public WiFi if handling sensitive work

For Your Development Projects

Create a .env file for local secrets
Add .env to .gitignore before your first commit
Create a .env.example with placeholder values
Never commit real API keys, passwords, or tokens
Review your .git history — if you accidentally committed secrets, revoke them immediately
Use environment variables in production (deployment platforms handle this)
Keep dependencies updated (npm update, pip install --upgrade)
Be cautious installing packages from npm, pip, etc. — check the source and download counts
Ask friends and trusted sources for recommendations before risking stranger danger.

If You've Been Hacked

If you think your password has been compromised:

Immediately change your password at that site
Check if your email was in a breach at https://haveibeenpwned.com
Change your email password (your email is the key to all other accounts)
Enable 2FA on that account
Review account activity for unauthorized actions
Monitor your credit (if financial info was exposed)

If your code repository was compromised:

Revoke immediately any exposed API keys, tokens, or credentials
Search your git history for secrets: git log -p | grep -i "password\|secret\|key"
Consider re-pushing a clean history (or just moving forward)
Rotate all credentials that were exposed

Remember: Security is Habit

You don't need to be paranoid, just consistent:

Use a password manager (one action, lifelong benefit)
Enable 2FA on important accounts (one-time setup)
Verify the source before clicking (takes 5 seconds)
Don't reuse passwords (password manager handles this)
Never put secrets in code (use .env)

These habits will protect you from 99% of common attacks.

Sources / additional material:

Check if your email was in a data breach:
https://haveibeenpwned.com
Open-source password manager:
https://bitwarden.com
OWASP cheat sheets on security topics (open the menu in the top left):
https://cheatsheetseries.owasp.org/

This article was generated with AI for the purpose of providing practical information. I have reviewed it for accuracy and edited it appropriately.

Editors, IDEs & Installing VS Code

Phillip A. Wessels — Fri, 04 Feb 2022 04:39:25 +0000

Everything you need to know to get started with VS Code: useful context to the world's most popular code editor, a simple install guide, and some useful keyboard shortcuts.

What's a code editor?

At its most basic level, a code editor could be a text editor such as Notepad. While it is possible to use such an application, there are dedicated applications for writing code with features such as syntax highlighting. Visual Studio Code (VS Code) is one of them, but you may also encounter others such as Notepad++, Sublime, and Zed. Many editors are extensible.

What's an Integrated Development Environment (IDE)?

An IDE is an application that comes with a comprehensive set of features for software development, including a code editor. Standalone editors are distinct from full IDEs, but the distinction is blurred once an editor is sufficiently extended.

What's the difference between Visual Studio Code and Visual Studio IDE?

Visual Studio Code is a code editor for a quick code-build-debug cycle with debugging, task running, and version control. Visual Studio IDE is for more complex workflows. While VS Code is free, Visual Studio IDE is premium software.

Why use VS Code?

VS Code is the most popular editor and has many features, including syntax highlighting, IntelliSense code completion, snippets, an integrated terminal, git support out of the box, and the ability to install extensions.

Sources / additional material:
The official VS Code documentation:
https://code.visualstudio.com/docs
https://code.visualstudio.com/docs/editor/whyvscode
https://code.visualstudio.com/docs/getstarted/userinterface
https://code.visualstudio.com/docs/editor/codebasics

💻 Set Up VS Code

Download the Visual Studio Code installer. https://code.visualstudio.com/download
- The Insiders edition is a nightly build with the latest features, but it is not a stable release and you may encounter issues. That said, you can have both versions installed. https://code.visualstudio.com/insiders/
Once it is downloaded, run the installer. This will only take a minute.

Sources / additional material:
https://code.visualstudio.com/docs/setup/setup-overview

Extensions

Extensions are key to the VS Code developer experience. You absolutely should explore extensions; often times you will do so to find the best & laziest way to do things. Extensions help make development more accessible. We'll be installing some extensions in this series.

Sources / additional material:
https://code.visualstudio.com/docs/editor/extension-marketplace

Settings

VS Code's settings are stored in settings.json. You can access this by opening the command palette and entering "Preferences: Open Settings (JSON)". .json files are in JSON - JavaScript Object Notation. This means settings have to be entered in a specific way.

The entire settings object is in a single pair of curly brackets ({}).
Keys - the names of different settings - need to be in quotation marks. E.g., "editor.tabSize".
Values can be strings (in quotation marks), numbers (without quotation marks), boolean (true/false), arrays (comma-separated elements in square brackets []), or objects (comma-separated key: value pairs in curly brackets {}). It's out of our scope here to cover data types, but you can be mindful of the indicated syntax.

Here are some settings that I recommend:

Set the default tab size to 2 spaces. I find that a minimal tab size makes it easier to share blocks of code.
Set the word wrap as on by default. I don't like scrolling left & right to read a long line of code.

{
  "editor.tabSize": 2,
  "editor.wordWrap": "on",
}

You can create settings specific to a certain project as well. Just create a .vscode directory at the top level, and inside it create a settings.json file. Any specific settings here will override those settings within VS Code's main settings.json.

Here you can see that since this is a React project, I am setting all JavaScript files (.js) to be associated with the JavaScript React language mode ("javascriptreact"). The icons update as well to the React icon.

Sources / additional material:
https://code.visualstudio.com/docs/configure/settings

📜Key Bindings: VS Code

Shortcut	Action
Ctrl+Shift+P	Show Command Palette
Ctrl+P	Quick Open, Go to File
Ctrl+Shift+X	Open Extensions panel
Ctrl+`	Show Integrated Terminal
Alt+Click	Insert additional cursors

📜Key Bindings: Navigating & Selecting Text

Shortcut	Action
Ctrl+→	Move the cursor one word to the right
Ctrl+←	Move the cursor one word to the left
Shift+→	Select text to the right
Shift+←	Select text to the left
Ctrl+Shift+→	Select the word to the right
Ctrl+Shift+←	Select the word to the left
Shift+Home	Select to the beginning of the current line
Shift+End	Select to the end of the current line
Ctrl+Shift+Home	Select to the beginning of the document
Ctrl+Shift+End	Select to the end of the document
Ctrl+A	Select all document content

Sources / additional material:
https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf
https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf
https://code.visualstudio.com/docs/configure/keybindings

Operating Systems, Terminals & Shells

Phillip A. Wessels — Wed, 02 Feb 2022 02:02:36 +0000

Welcome to Foundations of Digital Agency—a series built for anyone who wants to seize the tools and technology reshaping opportunity. You don't need permission. You don't need a computer science degree. You just need a cogntivie foundation and some scaffolding assembled from simple ideas. Once you have that sense of structure in mind, you can frame technology within it, move through it and build on top of it. Sound complicated? Language is magic. Once you start reading and applying it, the pieces -- mental models -- fall into place.

This tutorial starts that process. You'll learn why operating systems matter, what terminals and shells are, and why a Windows developer and a Mac developer can follow the same instructions without confusion. These concepts aren't optional—they're the vocabulary you need to navigate, troubleshoot, and build confidently.

So, get excited: this knowledge removes barriers. Once you understand these fundamentals, everything that comes next makes sense. You're not intimidated by strange commands or mysterious jargon. You recognize the patterns. You truly own the technology. That's agency.

Let's get started.

What is UNIX?

UNIX is the ancestor of many modern operating systems (OSs), like macOS and Linux. In 1969 at Bell Laboraties, Ken Thompson starting developing UNIX OS in PDP-7 computer assembly language. Dennis Ritchie joined Thompson and invented the C programming language. Then they rewrote UNIX in C, allowing different computers to run the code. UNIX also included user management and hierarchical file systems. Bell Labs released the first version of UNIX, Version 6 (V6), in 1976. Its design philosophy emphasizes small modular programs that can be used in combination for complex tasks:

Write programs that do one thing and do it well.
Write programs to work together.
Write programs to handle text streams, because that is a universal interface.

What is Linux?

The open-source GNU/Linux (commonly referred to as Linux) is the most famous Unix-like operating system (OS). Released in 1993, it spawned from the Free Software movement of the 1980s. Richard Stallman started the GNU Project of free software which needed a kernel. Fortunately, Linus Torvalds released the Linux kernel in 1991, which the GNU Project was able to combine with for a full OS that was released in 1993. Countless distributions have derived from GNU/Linux.

Why aren't all Unix-like operating systems called UNIX? Why do macOS and Linux use the same commands?

The UNIX brand is trademarked and "True UNIX" operating systems like macOS paid to be certified by The Open Group. While not officially UNIX, Unix-like OSs like Linux do fully or mostly meet the UNIX specification but are not certified; therefore, they do not use the UNIX name. The command line works the same, whether True UNIX or Unix-like. While not officially licensed, Unix-like OSs like Linux are designed to meet the UNIX specification.

What is the history of the modern Windows OS?

Windows NT, upon which the modern Windows and Xbox OSs derive from, started in 1977 with Digital Equipment's release of VMS 1.0 (one year after the release of the first version of UNIX). Many of the developers left Digital in 1988 to join Microsoft, which released Windows NT 3.1 in 1993 (the same year as the release of GNU/Linux).

How do Windows and UNIX-based OSs differ?

Both Windows NT and UNIX have roots in the mid-1970s and both were influenced by many identical theoretical OS concepts and principles. However, Windows and UNIX-based systems have different kernels engaging the hardware with different software built on top of those kernels, all based on different specifications. The software differs in many ways.

What is Windows Subsystem for Linux (WSL)?

Windows Subsystem for Linux lets developers run a GNU/Linux environment—including most command-line tools, utilities, and applications—directly on Windows, unmodified, without the overhead of a traditional virtual machine or dualboot setup. WSL 2 introduced an entirely new architecture that benefits from running a real Linux kernel. It runs in a lightweight virtual machine environment through a subset of Microsoft's Hyper-V features.

On Windows, why not use a virtual machine (VM) for Linux?

You can, but WSL requires fewer resources (CPU, memory, and storage) than a full VM. You can't easily work between the VM and Windows software.

What is a terminal?

A terminal is a program that runs a shell. There are many terminal applications, one being the Windows Terminal, another the integrated terminal in VS Code.

What is a shell?

A shell is an interpreter for command line language. Common shells include Bash and Zsh for UNIX-based operating systems, and PowerShell for Windows. Note: You cannot run UNIX-based commands through PowerShell, but there are many aliases matching UNIX-based commands which map to PowerShell cmdlets (that just means you kind of can... kind of).

What is a CLI?

A CLI is a Command Line Interface—any interface where you interact with a computer using text commands instead of clicking buttons. The terminal is the application; the shell is the interpreter; but CLI is the broader concept: communicating with software by typing commands. When you use Bash, PowerShell, or Zsh, you're using a CLI. When you run npm install or git commit, you're using a CLI. CLIs are powerful because they let you express complex instructions precisely and automate tasks through scripts. Many development tools—especially agentic AI tools like Claude Code—live entirely in the CLI.

Are Bash and PowerShell just shells?

The same names are used to refer to the shells' scripting languages as well.

Why are Bash and PowerShell both useful?

Bash is the scripting language of the Bash shell and its various packages, while PowerShell adds advanced efficiency as an object-oriented scripting language.

What is Zsh?

Zsh (Z shell) is a Unix shell that is largely compatible with Bash but adds many improvements such as better tab completion, spelling correction, and a richer plugin ecosystem. Since macOS Catalina (2019), Zsh has been the default shell on macOS, replacing Bash. On macOS you may see the prompt message "The default interactive shell is now zsh" — this is expected. Most Bash scripts and commands work in Zsh without modification.

What is PowerShell 7?

PowerShell 7 is the current cross-platform (Windows, Linux, and macOS), open-source version of PowerShell. It is the successor to both Windows PowerShell (which remains at version 5.1 and is built into Windows) and PowerShell Core (versions 6.x, a transitional release). PowerShell 7 is what you should install if you want to use PowerShell on macOS or Linux, or want the latest features on Windows.

You Now Have the Foundation

You understand operating systems. You know terminals and shells. You recognize that macOS and Linux speak the same language—UNIX—while Windows is fundamentally different, but that tools like WSL let you bridge that gap. You're not confused by terminology anymore.

This knowledge is power. In the next tutorials in this series, you'll further grow it, and start using the tools of the trade:

Editors, IDEs & Installing VS Code — Understanding your tools and setting up your editor
Installing Terminal & WSL — Setting up a development environment on Windows (Windows only; macOS users skip this)
Using VS Code with WSL — Configuring your editor for development (Windows only; macOS users skip this)
Using the Terminal in VS Code — Mastering the command line where your work happens (all platforms going forward)
And more, building toward full capability

Note: If you're on macOS, you already have a Unix-based terminal (bash/zsh) built in. You'll skip the Windows-specific setup articles and move straight to using the editor and terminal.

Why This Matters for AI-Assisted Development: Comfort with the terminal and command line is a prerequisite for using agentic AI tools like Claude Code and OpenClaw. These tools live in your terminal see your codebase, edit files, run commands, and handle version control—but they're not perfect, and you'll need to understand the fundamentals of CLIs.

With each step you'll grow the understanding to navigate confidently, make informed decisions, and see the world opportunistically -- through the eyes of someone who possesses the technology.

Sources / additional material:
https://web.archive.org/web/20240226110454/https://www.itprotoday.com/windows-78/nt-vsunix-one-substantially-better#close-modal
https://docs.microsoft.com/en-us/windows/wsl/about
https://www.udemy.com/course/the-linux-command-line-bootcamp/

This article was revised & expanded with AI for the purpose of providing practical information. I have reviewed it for accuracy and edited it appropriately.

Forem: Phillip A. Wessels

Containers & Agents with Docker & OpenClaw

The Problems Containers Solve

What is Docker?

The Mental Model: Images and Containers

The Dockerfile: Your Recipe

Docker Compose: Orchestrating Containers

Persistent State: Volumes and Data

Docker Hub: The Registry Pattern (Again)

Install Docker

Why OpenClaw in a Container?

Create Your OpenClaw Project

How OpenClaw's State Persists

Get API Keys

Set Up Discord

Build and Run Onboarding

Define Your Agent

Start the Gateway

Start Your Agent

The Power and Danger of Agents

You've Deployed a Production System

Daily Use: Running Your Agent

macOS: Auto-Start on Login (Optional)

Troubleshooting

All About AI & Using Claude

What is Machine Learning?

What are Large Language Models?

How Do LLMs Actually Work?

A Brief History: How We Got Here

Frontier Models

Open vs. closed

Business Models & Pricing

Cheaper/Free Alternatives

What Are AI Agents?

Basic Prompt Engineering

Pattern 1: Be Clear About Your Goal

Pattern 2: Provide Context

Pattern 3: Ask for Structure

Pattern 4: Use Examples

Risks and Guardrails

Hallucinations

Outdated Information

Biases

Security & Privacy

Overreliance

The Claude Ecosystem

Claude's Interfaces

Using Claude with Agents like OpenClaw

Understanding Claude Code (CLI)

Why Claude Code Matters for What's Next

Setting Up and Using Claude Code

Prerequisites

Installtion

Launch

Help

Your First Claude Code Command

More Examples

You're Now at the Frontier

On the Shoulders of Giants: Package Registries, Node & NPM

What is a Package?

What Problem Do Registries Solve?

What About GitHub?

How Registries Work

Risks You Need to Know

How Packages Are Versioned

What is Node.js?

Installing Node.js and NPM

Creating a Project: npm init

Understanding package.json

Installing Packages

Understanding node_modules

Updating Packages

Running Scripts

How Can I Audit My Packages for Security/Bugs?

Tools Worth Knowing About

Registries: A Pattern You'll See Everywhere

Commanding the Command Line

What does the command line do?

Why use the command line interface (CLI) instead of a graphical user interface (GUI)?

What am I looking at?

Creating a Project: `npm init`

What's `$`/`%`/`#` mean in the prompt? What's `sudo`?

What's `~`? Where am I?

Help, `--help` isn't working!