Dan's Blog

My AI Development Setup

Thu, 03 Sep 2026 01:00:00 +0000

tl;dr

Supacode
Pi
- pi-permission-system
Plannotator
Zed
revdiff
Ollama Cloud
- Primarily with glm-5.3-flash

My Workflow

1. Supacode

I start with supacode, it's basically the ghostty terminal but with some extra UI for creating and managing git worktrees. With AI I feel I am switching tasks a lot more frequently and worktrees make it easier to isolate work than regular branches do, especially on projects that use sqlite, since each worktree has its own database.

I use this .git/hooks/post-checkout script for initialising projects on new worktrees, but supacode also has support for defining setup and teardown scripts:

#!/bin/bash

base_repo_git=$(git rev-parse --path-format=absolute --git-common-dir)
base_repo=$(dirname "$base_repo_git")

# This check only runs on worktree creation
if [[ "$1" == "0000000000000000000000000000000000000000" ]]; then
    cp "$base_repo/config/master.key" "$(pwd)/config/master.key"
    cp "$base_repo/.envrc" "$(pwd)/.envrc"

    mise trust
    direnv allow

    bundle install
    npm install

    rails db:migrate
    rails db:seed
fi

2. pi

I am currently using pi as my agent harness, so far I've kept things very light, I haven't noticed the need for any plugins except for @gotgenes/pi-permission-system. This allows me to control which commands (and on which paths) pi can run without approval. By default everything asks for approval and I am building up the list of safe commands and paths that can auto-approve. You can see my config file here.

I mainly use the glm-5.3-flash model, it's fast, cheap and pretty reliable. It's not as good as Sol or Fable but it's good enough for most work. I will often use Sol or Fable to review the code generated by glm-5.3-flash, using my local-review skill.

3. Plannotator

Plannotator is the real star and is the missing piece I've been waiting for.

My workflow is to ask the agent to make a plan and write it to PLAN.md, I can then use /plannotator-annotate PLAN.md to open the plan in plannotator where I can comment on it in a Google Docs-style interface:

After I submit, the feedback is automatically sent back to the agent and it will make a new plan. Once I'm happy with the plan I tell the agent to get started. After the changes are complete I run /plannotator-review to review the changes in plannotator, where I can ask questions and provide feedback in a GitHub PR-style interface:

The questions get answered live but the feedback is sent after clicking "Send Feedback" where it is again automatically sent back to the agent and it works on the changes.

Plannotator also has a "Guided Review" function which splits the changes up into chunks and adds some extra context for each, this can be really helpful for larger changes:

4. Zed

If I want to drop in and edit some code myself (which is becoming increasingly rare) I will use zed. I also use revdiff as my terminal diff tool.

Other tools I've tried

maki - Maki is another lightweight harness, I really like it, I haven't uninstalled it yet but I have found pi to be consistently quicker
herdr - It's a bit like supacode but inside the terminal, which is nice if you aren't using ghostty, I just prefer the UX of supacode
omp - It's pi but with batteries included, it just felt a bit heavy to me and does a lot more than I need
orca - Orca is kind of a command centre for different harnesses and handles worktrees too, it's pretty impressive, but again I felt like it did too much, I preferred the simplicity of supacode and pi

I'm happy with this current setup, it really makes the AI agent feel more like a coworker, which is a bit weird but is a much nicer experience than copying and pasting things all over the place to get tools to link up. I think the biggest issue I have is reviewing and understanding all this AI-generated code to have the confidence to ship it, but plannotator is the best way I've found so far.

Sandboxed Claude with Zed

Fri, 24 Apr 2026 01:00:00 +0000

Here are my settings for running claude in zed using the nono sandbox.
This allows me to safely(-ish) run claude and skip the permission checks.

Setup

# Install claude-agent-acp
npm i -g @agentclientprotocol/claude-agent-acp

# Find the path to claude-agent-acp for the next step
which claude-agent-acp

Zed Settings

{
  "agent_servers": {
    "Claude Code (sandboxed)": {
      "type": "custom",
      "command": "nono",
      "args": [
        "run",
        "--allow-cwd",
        "--profile",
        "my-claude-code",
        "--",
        "/Users/dan/.local/share/mise/installs/node/22/bin/claude-agent-acp",
      ],
      "default_config_options": {
        "mode": "bypassPermissions",
      },
    },
  }
}

`nono` Profile

This file should be created in ~/.config/nono/profiles/my-claude-code.json

{
  "meta": {
    "name": "my-claude-code",
    "version": "1.0.0",
    "description": "Claude Code with additional project access"
  },
  "extends": "claude-code",
  "groups": {
    "include": ["git_config"]
  },
  "filesystem": {
    "allow": ["$WORKDIR", "$HOME/.claude", "$HOME/.superset", "$HOME/projects"],
    "read": ["$HOME/.local/share/mise/installs"]
  },
  "network": {
    "block": false
  },
  "env_credentials": {}
}

To double check it's all working I ask claude to list the files in my home directory - which should be blocked by nono.

If you have an issue then try running the full nono command in your shell, then you can see the full error message, you will probably need to tweak the paths in your nono profile.

Pipenv Crash Course

Mon, 05 Dec 2022 00:00:00 +0000

Installing packages

You can install packages with pipenv install.

The first time you do this it will create:

A new virtual environment
A file named Pipfile
A file named Pipfile.lock

pipenv install rich
pipenv install rich==12.6.0
pipenv install "rich<=12.5.1"

ℹ️ When adding new dependencies pipenv will update all other unpinned dependencies too.
You can use pipenv upgrade rich to install a package without updating everything else.

The `Pipfile` and `Pipfile.lock`

The Pipfile defines all of your dependencies and any versions you want to pin.

[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
rich = "*"

[dev-packages]

[requires]

The Pipfile.lock keeps track of the installed versions of your dependencies and any transitive dependencies, as well as hashes of the downloaded files.

You should never need to touch this file, it is managed by pipenv.

Updating

You can use pipenv update to update all dependencies and re-generate your lock file. If your Pipfile does not specify any version constraints then the latest versions will be installed.

You can use pipenv upgrade <some-package> to upgrade a specific package, only that package and it's dependencies will be updated.

Deploying

You should use pipenv sync when deploying your code to install dependencies as specified in the Pipenv.lock. You can use pipenv sync --system to install the packages without a virtual environment too.

Installing from another repository

One of the main benefits over regular pip is that you can specify where to install each individual dependency from, here is an example from the pipenv documentation:

[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[[source]]
url = "https://download.pytorch.org/whl/cu113/"
verify_ssl = false
name = "pytorch"

[dev-packages]

[packages]
torch = {version="*", index="pytorch"}
numpy = {version="*"}

This helps to avoid dependency confusion, an issue which recently bit pytorch.

Upgrading and housekeeping python dependencies

Sun, 05 Dec 2021 00:00:00 +0000

This post will provide give a quick overview into two tools to help keep your requirements.txt up to date and clean.

Updating dependencies using pip-upgrader

The first tool is pip-upgrader which provides an easy interface for finding out of date dependencies and updating them.

Install via pip:

python3 -m pip install pip-upgrader

Then run:

python3 -m pip-upgrade

You will be presented with a list of your dependencies which have new versions and you can select which to upgrade.

You will of course still need to check for breaking changes in your dependencies but this tool makes it easy to find what packages have new versions.

Figuring out what depends on what with pipdeptree

The second tool is pipdeptree which displays a dependency tree, making it easy to see which dependencies depend on other packages and help you clean up unused transitive dependencies.

python3 -m pip install pipdeptree
python3 -m pipdeptree

A weird bug due to having Excel installed

Sun, 07 Nov 2021 00:00:00 +0000

A while ago I was working on building a basic web page that allowed a user to upload a CSV file to an S3 bucket using a presigned S3 upload URL.

This was easy enough, I tell AWS I want to upload a file with a Content-Type of text/csv and it will give me a pre-signed URL that I can use to upload without authenticating at the time of upload - nice and easy.

The confusing part came when I gave it to the user and they got an error that the presigned URL was invalid, which was odd since it ran on my machine perfectly fine and I sent the user the exact file I was testing with.

After some debugging I noticed the Content-Type from the users request was not text/csv but was application/vnd.ms-excel, for the exact same file.

It turns out that if you have Microsoft Excel installed (which I did not but the user did) it "hijacks" the MIME-Type of CSV files - since Excel will handle the file.

On Windows the MIME-Type of any given file type is stored in the registry, under HKEY_LOCAL_MACHINE\Software\Classes and when using Excel as the default application for .csv files it will update their MIME-Type to application/vnd.ms-excel.

In the end I just blanked out the Content-Type header (probably not the best solution but this was a only used by a single user and was behind authentication) and everything started working again.

Source

How to re-use SQLAlchemy models across multiple tables

Thu, 22 Apr 2021 01:00:00 +0000

Source Code

When using SQLAlchemy declarative models you might find yourself wanting to re-use a model for multiple tables, this post will show you how to do it.

A new base model

A lot of tables share common columns, like an id, last_updated, etc... To handle this we can declare a new base model that all others inherit from:

def snake_caser(text):
    """
    Converts camelCase/PascalCase to snake_case
    """
    return re.sub(r'(?<!^)(?=[A-Z])', '_', text).lower()


class CustomBase(db.Base):
    """
    This is our customised base table
    It includes a table name generator that converts the ClassName to class_name
    an ID primary key column and a basic repr() method

    Any models that inherit from this will automatically get these things
    """
    __abstract__ = True

    @declared_attr
    def __tablename__(cls):
        return snake_caser(cls.__name__)

    id = Column(Integer, primary_key=True)

    def __repr__(self):
        return f'<{self.__class__.__name__} {self.id}>'

The key part to this is __abstract__ = True, this tells SQLAlchemy that this isn't a real table (this is documented here).

This base also includes an id column, a basic repr method and a __tablename__ declared attribute (more on this in a bit) that takes the class name and converts it to snake case.

The re-usable models

Now we can create our abstract base for our real tables:

class UserBase(CustomBase):
    __abstract__ = True

    label = ''

    # Columns
    name = Column(String(40))
    email = Column(String(120))

    # Relationship
    @declared_attr
    def posts(cls):
        return relationship(f'Post{cls.label}', backref=cls.__tablename__, lazy=True)


class PostBase(CustomBase):
    __abstract__ = True

    label = ''

    # Columns
    body = Column(Text(240))
    private = Column(Boolean)

    @declared_attr
    def user_id(cls):
        return Column(Integer, ForeignKey(f'user_{snake_caser(cls.label)}.id'))

These are both similar to the original CustomBase but have dynamic foreign keys and relationships based on the label property.

These are declared using the @declared_attr decorator which let's us use methods as attributes, which let's us dynamically create the mappings (documented here).

Now we can declare our real models, inheriting from UserBase and PostBase and all they need is a label property:

# ProductA Models
class UserProductA(UserBase):
    """
    This extends the UserBase model so is a copy of that but with the table name user_product_a

    We can overwrite or extend however we want but the only the we NEED is to define the label
    The label should be cased the same as the class name
    """
    label = 'ProductA'


class PostProductA(PostBase):
    label = 'ProductA'

It's as easy as that, if you add a label property to the child models everything will just work ™️.

UserProductA will have a relationship with PostProductA and PostProductA will have a foreign key to user_product_a.

Dan's Blog

My AI Development Setup

tl;dr

My Workflow

1. Supacode

2. pi

3. Plannotator

4. Zed

Other tools I've tried

Sandboxed Claude with Zed

Setup

Zed Settings

nono Profile

Pipenv Crash Course

Installing packages

The Pipfile and Pipfile.lock

Updating

Deploying

Installing from another repository

Upgrading and housekeeping python dependencies

Updating dependencies using pip-upgrader

Figuring out what depends on what with pipdeptree

A weird bug due to having Excel installed

How to re-use SQLAlchemy models across multiple tables

A new base model

The re-usable models

`nono` Profile

The `Pipfile` and `Pipfile.lock`