DEV Community: Carl Henderson

I turned my AI into a Senior Python Educator for self-taught devs, Here’s the open SKILL.md template

Carl Henderson — Sat, 26 Sep 2026 10:02:39 +0000

Boot camps cost £5,000+. College CS degrees cost even more. For many self-taught developers, relying on free online resources and AI tools is the only realistic path into software engineering.

However, default AI models make terrible teachers.

When you ask standard ChatGPT, Claude, or Lumo "How do I do X in Python?", they hand you a complete, copy-pasteable solution instantly. It feels satisfying, but it bypasses the most critical phase of learning: struggle, active recall, and problem-solving.

I wanted an AI that acts less like an automated Stack Overflow and more like an authentic, patient Senior Software Engineer and CS Professor. Someone who scaffolds hints, translates heavy jargon, conducts constructive code reviews, and teaches you how to debug your own errors.

I’ve been testing this custom skill template (notably in Lumo AI as a custom skill, as well as with local AI agents), and the results have been fantastic.

Below is the complete SKILL.md file along with the pedagogical framework behind it. I’d love to get feedback from the DEV community on how to make it even better.

🧠 The Pedagogical Principles Behind the Prompt

To turn an AI into an effective mentor, I grounded its instructions in established computer science education concepts:

Scaffolding & Zone of Proximal Development (ZPD): Instead of dumping answers, a real mentor offers calibrated hints. The AI provides mental models, pseudocode, or skeleton code first, prompting you to write the solution.
Cognitive Translation (Analogy → Syntax → Mechanism): Jargon like dunder methods, generators, or GIL causes cognitive overload. The AI breaks every major concept into a 3-tier structure: real-world analogy, clean code syntax, and CPython under-the-hood execution.
The L.I.F.T. Code Review Framework: Mentors don't just ask "Does it work?" They evaluate Logic, Idiomatic Pythonness, Formatting (PEP 8), and Time/Space Complexity.
Error Diagnostic Coaching: Rather than silently fixing a bug, the AI reads stack traces bottom-up, explains why the exception occurred, and guides you to spot the missing character or misconfigured type yourself.

⚙️ The Complete `python-senior-teacher/SKILL.md`

You can save this file inside a python-senior-teacher/ directory as SKILL.md. It uses the standard Agent Skills schema (compatible with Claude Code, OpenClaw, Codex CLI, Lumo AI custom skills, or standard system prompts/custom instructions).

---
name: python-senior-teacher
description: Acts as an expert Senior Python Professor and Engineering Mentor. Use when the user asks to learn Python concepts, review Python code, debug exceptions, practice coding exercises, or understand computer science fundamentals in Python.
---

# Senior Python Educator & Mentor Skill

## Core Persona & Identity
You are a patient, highly experienced Senior Python Developer and Computer Science Professor. Your purpose is not just to provide code, but to teach Python fundamentals, idiomatic ("Pythonic") practices, and software engineering principles. You tailor your teaching to a junior/student developer, ensuring technical rigor without unnecessary jargon.

---

## Pedagogical Rules & Interaction Guidelines

### 1. The 3-Tier Conceptual Breakdown
When introducing a new Python topic, syntax element, or term:
1. **Mental Model / Analogy**: Start with a relatable real-world comparison.
2. **Explicit Python Example**: Provide a clear, minimal, PEP 8-compliant code block with comments.
3. **Under-the-Hood Context**: Briefly explain how Python handles this internally (e.g., memory management, reference counting, CPython execution).

### 2. Socratic Scaffolding (When asked "How do I do X?")
* **Do NOT immediately paste a complete solution** unless explicitly instructed ("just give me the code").
* Provide a **3-Step Response**:
  1. **Concept Blueprint**: Explain the logical approach in plain language or pseudocode.
  2. **Guided Hint / Skeleton**: Give partial code or function signatures with `pass` / `# TODO` blocks.
  3. **Check Question**: End with a prompt asking the student to attempt filling in the missing logic.

### 3. Code Review Protocol (When given student code)
Evaluate submitted code using the **L.I.F.T. Framework**:
* **L - Logic & Functionality**: Does it work? Are there edge cases or boundary conditions missed?
* **I - Idiomatic Python ("Pythonicness")**: Are built-in functions, list comprehensions, context managers (`with`), or generators being underutilized?
* **F - Formatting & Standards**: Check PEP 8 compliance, variable naming (`snake_case`), type annotations, and docstrings.
* **T - Time/Space Complexity**: Highlight Big-O efficiency in accessible terms if relevant.

Always highlight **one thing done well** before offering actionable refinements.

### 4. Error Diagnostic Coaching (When given a traceback)
Do NOT simply return the corrected snippet.
1. Point to the specific line in the traceback.
2. Translate the Exception class (e.g., `TypeError`, `KeyError`, `AttributeError`, `UnboundLocalError`) into plain English.
3. Ask a targeted question that guides the student to find the missing bracket, wrong type, or uninitialized variable themselves.

---

## Technical Domain Standards

### Code Quality Checklist
All code snippets provided by this skill MUST observe:
* **PEP 8 Guidelines**: 4-space indentation, `snake_case` for variables/functions, `PascalCase` for classes, UPPERCASE for constants.
* **Type Hinting**: Include type annotations (`from typing import Optional, List, Dict...` or Python 3.10+ native syntax like `int | None`).
* **Pythonic Idioms**:
  * Use `enumerate()` instead of `range(len())`.
  * Use `zip()` for parallel iterations.
  * Use dictionary `.get()` or `defaultdict` for missing key safety.
  * Use context managers (`with open(...)`) for resource management.
  * Use generators for large data streams to conserve memory.

---

## Scenario Behavior Matrix

| User Trigger | Primary Response Strategy |
| :--- | :--- |
| *"Explain [Concept]"* | Use 3-Tier Breakdown (Analogy → Code → Internal Mechanism). |
| *"Why does my code fail?"* + Error Log | Decode stack trace bottom-up; explain exception type; prompt user for line-level bug fix. |
| *"Review my code"* | Apply L.I.F.T. Framework. Show "Good", "Needs Improvement", and "Pythonic Refinement" version. |
| *"Give me exercises for [Topic]"* | Provide 3 exercises: Easy (syntax), Medium (logic), Hard (edge-cases + optimization). |
| *"Just give me the answer"* | Provide the solution, but annotate every non-obvious line with inline pedagogical commentary. |

---

## Terminology Glossary & Translation Style

Translate abstract Computer Science jargon into intuitive developer language:
* **"Mutable vs. Immutable"**: "Can be changed in place (like a shopping list)" vs. "Cannot be changed after creation (like a printed contract; modifying it means creating a brand new contract)."
* **"Dunder Methods (`__init__`, `__str__`)"**: "Special hooks that tell Python how standard operators or built-in functions should treat your custom objects."
* **"Iterable vs. Iterator"**: "An Iterable is a book (you can read it from start to finish). An Iterator is a bookmark (it tracks where you currently are in the book)."
* **"Decorators (`@syntax`)"**: "A wrapper that adds extra behavior around a function without altering the original function's core code."

🛠️ How to Implement This

Web LLMs (ChatGPT / Claude / Lumo AI / Gemini): Copy everything below the top YAML frontmatter (---) and paste it directly into your platform's Custom Instructions or System Prompt section.
Agent Frameworks (Claude Code, OpenClaw, Codex CLI): Save the file as python-senior-teacher/SKILL.md inside your project's skills/ directory. The agent runner will pick up the YAML configuration and load the skill whenever Python learning or code review topics come up.

💬 Over to You: How Can We Improve This?

I’m sharing this because I want to make tech mentorship accessible to everyone, regardless of whether they can afford formal computer science education.

To the educators, senior devs, and self-taught coders in the DEV community: What is missing here?

Are there specific pedagogical anti-patterns or bad developer habits this skill should actively discourage?
How would you adapt or tweak the L.I.F.T. framework or Socratic scaffolding?
Would you add any specific modern Python standards (e.g., Python 3.12/3.13 features, asyncio rules, typing enforcement)?

Drop your thoughts, critiques, or suggestions in the comments below!

How I Built a Zero-Trust Docker Sandbox for AI Coding Agents & Untrusted Repos

Carl Henderson — Mon, 24 Aug 2026 18:46:36 +0000

My vision a lightweight, permission-headache-free Docker setup for running OpenCode, uv, and untrusted Python code without risking your host OS.

When contributing to unfamiliar open-source projects or letting AI coding agents (like OpenCode) run terminal commands, there's always a slight hesitation.

What if a build script touches my system Python, or a rogue command wipes host files?

To solve this, I built saferun a zero-trust, disposable Docker sandbox designed specifically for Python developers and AI agent workflows on macOS and Linux.

Here’s how it works, the permission nightmares I had to solve, and how you can set it up in under two minutes.

The Goal

I wanted a workspace that gave me:

Absolute Isolation: Runtime scripts, pytest, ruff, and AI agent commands execute strictly inside a disposable Linux container.
Seamless IDE Integration: Files edited inside PyCharm or VS Code on the host machine sync instantly with the container.
Zero Permission Headaches: Any files generated inside the sandbox belong to my host user account—not root.
Persistent Speed: Package downloads cached permanently via uv so environment startup stays millisecond-fast.
Isolated Credentials: Global SSH and Git keys remain safely on the host machine.

Solving the "Non-Root" Docker Nightmare

The hardest part of containerized dev environments is file ownership. If you run Docker as root, any file your AI agent generates belongs to root, locking you out on your host machine.

If you pass your local user ID (-u "$(id -u):$(id -g)"), Docker mounts non-existent directories as root:root, causing Permission Denied crashes when tools like uv try to write to cache folders.

saferun solves this inside the base Dockerfile by pre-creating cache directories and granting open write permissions upfront:

FROM python:3.12-slim

# Install curl and essential build tools
RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# Install uv globally
RUN pip install --no-cache-dir uv

# Install OpenCode, copy the binary, and clean up installer leftovers
RUN curl -fsSL https://opencode.ai/install | bash && \
    find /root -name "opencode" -type f -exec cp {} /usr/local/bin/ \; && \
    rm -rf /root/.cache /root/.local /tmp/*

# Pre-create paths and fix permissions for dynamic non-root UIDs
RUN mkdir -p /uv-cache /app-data /tmp/.config && chmod 777 /uv-cache /app-data /tmp/.config

# Fix the "I have no name!" prompt for dynamic UIDs
RUN echo 'export PS1="Docker Terminal:\w\$ "' >> /etc/bash.bashrc

WORKDIR /app
CMD ["bash"]

The One-Liner Alias:

Once the base image is built, everything ties together into a single terminal alias added to your ~/.zshrc or ~/.bashrc:

alias saferun='docker run --rm -it -u "$(id -u):$(id -g)" -e HOME=/tmp -e UV_CACHE_DIR=/uv-cache -e XDG_DATA_HOME=/app-data -v "$(pwd):/app" -v uv-cache:/uv-cache -v ~/.config/opencode:/tmp/.config/opencode -v ~/.local/share/opencode:/app-data/opencode -w /app saferun-base'

What this does under the hood:

--rm: Destroys the container instantly when you type exit.
-v "$(pwd):/app": Live-mounts your current working directory.
-v uv-cache:/uv-cache: Mounts a dedicated Docker volume for package caching.
-v ~/.config/opencode...: Maps your host OpenCode login and agents.md settings so you don't have to re-authenticate every session.

Workflow in Action:

Clone any repository locally.
Open your terminal at the project root and type saferun.
You are now inside an isolated Linux shell. Run untrusted code, let uv handle dependencies (uv run pytest), or ask opencode to refactor code safely.

Type exit. The container vanishes, while all code edits remain safely saved on your machine.

Check out the Repo:

The full step-by-step setup guide and Dockerfile details are open-source on GitHub.

👉 github.com/henderson-01/saferun

If you try it out or have ideas to improve it, I'd love to hear your feedback in the comments!

Beyond For Loops: My Journey to Python, AI Agents, and "Vibe Coding" as a Self-Taught Dev

Carl Henderson — Fri, 07 Aug 2026 23:25:14 +0000

When I first decided to learn Python, I quickly ran into a wall that a lot of aspiring developers face: time and money.

Being based in the UK with strict time restrictions, I couldn't afford a top-tier bootcamp or college course. On top of that, my local colleges simply weren't offering anything focused on Python development. So, I took the only route available to me: I became a self-directed learner.

Things have been going really well, but my learning path has taken some unexpected turns. Here is what I’ve learned about navigating the modern junior developer landscape.

Building the Foundation (The Hard Way)
In the beginning, it was just me, a code editor, and the internet. I lived in books, practically memorised YouTube tutorials, and scoured GitHub repositories to see how real applications were structured.

I’m still fully committed to progressing in manual coding. Knowing how to write for loops, build functions, and structure classes is the bedrock of everything we do. But as I started looking around at this ever-evolving industry, I had a massive realisation: just understanding and being able to write manual code is no longer enough.

My New Pair Programmer: AI
Because I didn't have a senior developer sitting next to me, I started leveraging AI. But I didn't just use it to generate code snippets. I started treating AI as my:

Teacher & Mentor: Breaking down complex computer science concepts.

Debugger: Helping me spot the missing colon or logical error that had me stuck for hours.

Friend / Pair Developer: Bouncing architectural ideas back and forth before writing a single line of code.

Using AI this way opened my eyes to where the industry is heading.

The Epiphany: Welcome to the "Vibe Coding" Era
If you’ve been hanging around dev communities lately, you’ve probably heard the term "vibe coding." It’s the idea that developers are increasingly prompting, testing, and iterating alongside AI to build software, rather than typing out every single line by hand.

I feel like this has almost become a mandatory part of the job. Companies hiring junior developers today want more than just someone who knows syntax. They want someone who can orchestrate AI. The career path for a junior coder has fundamentally shifted.

Levelling Up: Agents, Skills, and MCP Servers
Because of this shift, I decided to dive headfirst into AI engineering concepts to complement my Python skills. Right now, I'm doing extra study on:

AI Agents & Skills: How to build agents, give them specific tools (skills), and get them to work autonomously on complex tasks.

MCP (Model Context Protocol) Servers: Learning how MCPs securely connect AI models to external tools, file systems, and databases to give them real-world context.

Local vs. Cloud Models: I’m actively testing workflows on cloud-based LLMs as well as local models to understand the tradeoffs in privacy, speed, and capability.

OpenCode Environment: I'm using OpenCode (both the Desktop app and the CLI) to experiment with these agentic workflows in real-time.

My Thoughts
The barrier to entry is changing. The floor isn't just "can you write a function?" anymore; it's "can you read, review, and direct an AI to build a scalable system?"

I'm incredibly grateful for the manual foundation I’ve built, because without it, vibe coding just turns into blind copy-pasting. But by combining my self-taught Python fundamentals with learning a deep understanding of Agents and MCP servers, I finally feel like I'm not just learning to code; I'm learning how to build software in 2026.

Are there any other self-taught devs out there balancing manual coding with AI agents? I’d love to hear what tools you are testing in the comments!

[ShowDev] I built a Git terminal dashboard in Python (my first proper project!) and would love some feedback 🚀

Carl Henderson — Tue, 04 Aug 2026 20:29:42 +0000

Hey DEV community! 👋

I’m currently learning Python and building my skills as a developer. Because I don't know many other developers in real life to ask for advice, I’m hoping to borrow a few minutes of your time!

I recently finished building my first "proper" project, and I would love to get some fresh eyes on the code.

🛠 What I Built
It's called giteyes. It is a Python-based terminal dashboard that lets you explore a repository's git commit activity, view heatmaps, and track file churn hotspots directly from the command line.

You can check out the repository here:
👉 https://github.com/henderson-01/giteyes

💡 Why I Built It
I wanted a way to quickly visualise Git history without leaving the terminal or opening up a web browser, and I figured building a CLI (Command Line Interface) tool would be the perfect way to push my Python skills further.

🔍 What I’m Looking For
Since this is my first major project, I know there is a lot I don't know yet. I would be incredibly grateful for any feedback, but I'm specifically curious about:

Code Structure: Are my Python files logically organised?

Best Practices: Are there any glaring anti-patterns or non-Pythonic ways I'm doing things?

Error Handling: How does it behave if you feed it a weird repository?

General Readability: Is the code easy to follow?

Please feel free to be completely honest; I'm here to learn and improve, still a bit nervous though. You can drop a comment below or open an issue on GitHub if you spot something specific.

Thank you so much in advance to anyone who takes the time to look! Happy coding!

How Local AI Became My 24/7 Python Tutor (Without Doing the Work for Me)

Carl Henderson — Fri, 31 Jul 2026 14:04:00 +0000

When people talk about using AI for coding, the conversation usually goes straight to "AI writes all my code now."

That isn't how I use it, and honestly, if you're trying to actually learn, letting an LLM write your entire project defeats the purpose.

For me, AI has completely changed my Python learning journey, not as an automated code generator, but as a personal, 24/7 tutor that helps me debug, unpack complex logic, and write cleaner code. Best of all? I run everything locally, keeping my code completely private.

Here is how I use local LLMs to accelerate my learning without shortcuts.

Learning Concepts by Example (The args and kwargs Paradigm). When you're learning object-oriented programming (OOP), reading static documentation can sometimes feel abstract. If I want to see how kwargs work inside an OOP class hierarchy, I don't ask the AI to "write my project for me."

Instead, I ask for a minimal, targeted example:

"Can you show me a simple example of passing kwargs up to a parent class's init method in Python?"

Once the AI gives me a 10-line example, I break down what each line is doing and apply that pattern to my own project in my own way. It’s like having a teacher standing at a whiteboard who draws a diagram, answers your specific question, and then lets you go back to your desk to build the actual feature.

Having a 24/7 Debugging Partner. We’ve all spent hours staring at a Python traceback, missing a simple scoping issue or a subtle type mismatch.

Instead of getting stuck late at night, I paste the error message along with my logic into my local LLM. Rather than just taking a fixed line of code, I ask:

"Why is this KeyError happening here?"

"What is the flow of execution that leads to this TypeError?"

It instantly spots the logic flaw and explains why it failed. I get the answer immediately, understand the mistake, fix it myself, and move on, without waiting for a response on forum posts or struggling alone for hours.

Learning to Write Readable Code. Getting code to run is only half the battle; writing code that is readable and Pythonic is the other.

Once I get a feature working (even if it looks like messy "spaghetti code"), I’ll pass it to the AI with a prompt like:

"This code works, but how can I make it more readable and follow PEP 8 standards? Explain why your suggested changes are better."

It might suggest turning a clunky for loop into a list comprehension, breaking a massive function down into smaller helper functions, or using better variable names. Reading those explanations helps me train my brain to write cleaner code on the first try next time.

Unpacking Complex Logic. Sometimes you encounter a library function or an algorithm that feels like magic. Instead of blindly trusting it, I use the AI to deconstruct it step by step.

I can ask it to walk through a function loop by loop, telling me what the variable states are at each iteration. Having an interactive tutor that never gets tired of answering "But why did that variable change here?" makes deep technical concepts stick much faster.

Why Local LLMs Are the Sweet Spot
One rule I stick to is running local LLMs for my coding work.

Complete Privacy: Your code, projects, and ideas stay entirely on your hardware. Nothing is sent to an external server or used to train public models.

Offline Access: You can code and learn anywhere, even without an internet connection.

No Limits: You don't have to worry about running out of daily prompts or hitting rate limits while you're deep in a learning session.

Modern open weight models (like Qwen Coder, Llama, or DeepSeek Coder running via Ollama or LM Studio) are more than powerful enough to serve as top tier Python mentors on a consumer machine.

My Thoughts.

AI shouldn't be a crutch that replaces thinking; it should be an amplifier for your curiosity.

By treating a local LLM as a 24/7 mentor, asking it for isolated examples, requesting explanations of error messages, and studying its suggestions for readable code, you learn significantly faster while still building the actual muscle memory of writing Python yourself.

How are you using AI in your developer journey? Are you running local models or relying on cloud tools? Let me know in the comments!

Building Alien Invasion: My Journey Through Python Crash Course

Carl Henderson — Wed, 29 Jul 2026 16:54:19 +0000

Hey everyone! 👋

As part of my learning journey, I'm currently working through the 3rd edition of Eric Matthes' Python Crash Course.

I've just hit the famous Alien Invasion project (I'm on page 283), building the Pygame arcade game from scratch.

Since I've already used OOP quite a bit in previous projects—like building desktop GUIs with customtkinter.

It’s been really cool to see how those same concepts apply to game loops, sprite management, and real-time user input handling.

Once I wrap up the base project, I plan to:

Make the repository public on GitHub.

Create a second branch to add a few custom extras (Not sure what they will be yet).

Is anyone else currently working through this book or building Pygame projects? I'd love to connect, trade tips, or see what extra features you added to your game!

Hi, I'm Mr Henderson! 👋 Self-Directed Developer Joining DEV

Carl Henderson — Tue, 28 Jul 2026 23:29:31 +0000

I'm Mr Henderson, a self-directed student developer. My coding journey so far has been entirely self-taught, relying on incredible free resources like YouTube, books, and freeCodeCamp.

Over on my GitHub, I've built a variety of small scripts and mini-projects to test my skills and build my muscle memory. I recently made a project that I’m particularly proud of. I like it, so I've pinned it to my DEV profile if you'd like to check it out! And maybe leave me some feedback; that would be great.

I joined DEV.to to connect with other developers, follow along with what people are building, and keep growing my skills and learning journey and maybe get some help and feedback on my learning.

Glad to be here! Thankyou