AI and ML

Cover photo by Conny Schneider https://unsplash.com/@choys_

ML Introduction

Welcome to my Machine Learning and AI notebook.

🧱 AI and ML Fundamentals

πŸ—ƒοΈ Data Collection and Annotation

πŸ“š LLMs and Small/Specialised Language Models (SLMs)

ML Best Practices

Machine learning is a complex and multifaceted activity that requires the combination of a number of success factors in order to work. In order to execute machine learning well, it is important to have a good understanding of the processes and variables that frequently come into play together. Here I document and lay out some of the best practices and ML processes that I have learned and continue to learn during my career.

A personal bugbear of mine is when people refer to machine learning as "an art rather than a science". It is true that machine learning involves random-seeming aspects that could be conflated with magic or wizardry. There are a lot of ways that poorly thought-through or executed machine learning projects can go wrong. However, there are well established protocols and principles that can guide a project towards success and we can execute projects in a risk-averse, incremental way allowing us to fail fast before a large amount of time and energy has been spent on a project.

Key Principles

Garbage In; Garbage Out

Machine learning is all about trying to infer statistical relationships between data. There are a lot of reasons why this might not work well which we will explore in depth. It's always important to remember that if you have bad data or a flawed hypothesis, your model is not going to perform well. Conversely, if your model is performing really well (perhaps "too good to be true" levels of well ) this can be a red flag that something is wrong with your data or your process which leads into...

Professional Pessimism

I love this phrase that I picked up during my career stint as a QA Engineer. If something appears to be too good to be true, it probably is. Always question your results and double check your working.Β Typically if a machine learning model is achieving high-90% in appropriate performance metrics, it is worth your time to investigate whether something weird is happening.Β You may have training data in your test set (i.e. your model got hold of the exam answer sheet) or your model may have found a short cut. For example, if all the positive examples of fractured ribs come from x-rays of women and all the negative examples come from x-rays of men then the model may have just learned to separate male and female anatomy rather than what a fractured rib looks like.

Keep it Simple, Stupid (KISS)

As tempting as it might be to want to use the latest and greatest ML models, always start with the simplest approach possible and disqualify these approaches based on sound theoretical rationale or empirical experimentation:

Keep Receipts

Machine Learning is usually an iterative process. As you move through this process it is important to understand where you came from and why at all times and to be able to refer back to earlier results and hypotheses. Furthermore, in a business setting, you will likely be asked questions about how work that you did days or weeks ago compares to your current iteration of thinking.Β 

Keeping receipts is about using simple tools (good note taking and ticket hygiene) in combination with more specific purpose-built AI and ML tooling to ensure that you can answer these questions at all times.

Deep Learning Best Practices

For deep learning I like to work with torch. My opinion on how torch code should be written aligns quite closely with this styleguide

Model Quantization

Deploying models that are performant (obviously statistically but in this context I primarily mean computationally) is challenging when you are working with large models such as BERT etc.

Quantization involves compressing model weights into smaller, more efficient representations. Weights are normally stored as 32 bit floating point numbers but they can be compressed into 8 bit integers with a very small amount of performance loss.

This article talks about how to do quantization effectively (mirror).

Quantization with Optimum and OpenVino

Openvino is an open source framework from Intel that provides quantization and x86 CPU support for torch and huggingface transformers.

SpaCy GPU

Set Up Environment

It's relatively easy to use SpaCy with a GPU these days.

First set up your conda environment and install cudatoolkit (use nvidia-smi to match versions of the tookit with the drivers):

Run nvidia-smi:

image.png

Create conda env:

conda create -n test python=3.8
conda activate test
conda install pytorch cudatoolkit=10.2 -c pytorch

Installing SpaCy

Now install spacy - depending on how you like to manage your python environments either carry on using conda for everything or switch to your preferred package manager at this point.

conda install -c conda-forge spacy cupy

or

pdm add 'spacy[cuda-autodetect]'

Download Models

Download a spacy transformer model to make use of your GPU/CUDA setup:

python -m spacy download en_core_web_trf

Using GPU

As soon as your code loads you should use theprefer_gpu()or require_gpu() functions to tell spacy to load cupy then load your model:

import spacy

spacy.require_gpu()

nlp = spacy.load('en_core_web_trf')

Now you can use the model to do some stuff

doc = nlp("My name is Wolfgang and I live in Berlin")

for ent in doc.ents:
    print(ent.text, ent.label_)

You can check that the GPU is actually in use with nvidia-smi:

image.png

Also if you try to use transformer models without a GPU it will hang for AGES and max out your CPUs - another tell that something's not quite right.

SpaCy CoRef

Spacy Coref is an experimental coreference resolution model in spacy

The project repository is here.

There is currently a hard dependency on the LDC OntoNotes dataset which makes it difficult to use without spending money. Hopefully they will release a pre-trained model soon

Core Scientific Concepts (CoreSC)

Core Scientific Concepts (CoreSC) is an annotation scheme used to delineate different parts of scientific discourse in a scientific paper.

There are 11 categories:

Classification Methods

References

Stratified Sampling in Pandas

df = pd.read_csv("path/to/data.csv")

df.groupby('Category', group_keys=False).apply(lambda x: x.sample(frac=0.1, random_state=42))

From Crowd Ratings to Predictive Models of Newsworthiness to Support Science Journalism

Authors:

Notes

Stable Diffusion

Web UI API

Run the web UI with:

./webui.sh --api

Β 

Example Python Script

import webuiapi


# create API client
api = webuiapi.WebUIApi()

# create API client with custom host, port
#api = webuiapi.WebUIApi(host='127.0.0.1', port=7860)

# create API client with custom host, port and https
#api = webuiapi.WebUIApi(host='webui.example.com', port=443, use_https=True)

# create API client with default sampler, steps.
#api = webuiapi.WebUIApi(sampler='Euler a', steps=20)

# optionally set username, password when --api-auth=username:password is set on webui.
# username, password are not protected and can be derived easily if the communication channel is not encrypted.
# you can also pass username, password to the WebUIApi constructor.

result1 = api.txt2img(width=512,height=768,
                    prompt="Morgan Freeman in star wars jedi robe",
                    negative_prompt="ugly, out of frame",
                    seed=1003,
                    styles=["anime"],
                    cfg_scale=7,
                    steps=30,
#                      sampler_index='DDIM',
#                      steps=30,
#                      enable_hr=True,
#                      hr_scale=2,
#                      hr_upscaler=webuiapi.HiResUpscaler.Latent,
#                      hr_second_pass_steps=20,
#                      hr_resize_x=1536,
#                      hr_resize_y=1024,
#                      denoising_strength=0.4,
                    alwayson_scripts = {
                        "ADetailer": {
                        "args": [
                            {
                            "ad_model": "face_yolov8n.pt"
                            }
                        ]
                        }
                    }
                    )

result1.image.save("out.png")


Β 

AI Causing Chaos

So much AI turns out to be low-waged people in a call center in the Global South pretending to be robots that Indian techies have a joke about it: β€œAI stands for β€˜absent Indian’” - Cory Doctorow

I am collecting examples of AI fails by people who either deliberately or naively mislead about the capabilities of AI.

2024

2023

Tasks

Tasks within ML and NLP

Tasks

Question Answering

Approaches

Fine-Tuning Sentence-BERT for Question Answering

CapitalOne produced a tutorial (mirror) about using sentence-transformers for Question Answering.

Haystack

Haystack is an open source NLP framework for use cases involving large collections of documents. It could be used for searching and ranking type use cases and question answering type use cases.

Haystack works flexibly with existing document stores including DB systems and ElasticSearch.

Tasks

Coreference Resolution

Co-reference Resolution (CR) is the task of deciding whether two entity mentions refer to the same instance or not.

For example in:

Joe Biden appeared at the event at 8pm. The president was wearing a Louis Vuitton Tuxedo.

The objective is to identify that Joe Biden and The president are the same entity.

Coreference Detection is related to Relationship Extraction (RE) - in fact you could even say that CR is a special case of RE in the sense that we are interested in the special relationship between entity mentions when they both refer to the same entity.

In-Document Coreference Resolution

This is the "normal" CR case in which you're trying to resolve mentions of entities within the same document e.g. a single news article.

Approaches

Cross-Document Coreference Resolution

Cross-Document Coreference Resolution (CDCR) is when you try to link named entity references across multiple input documents. A use case might be identifying that a number of news articles do actually refer to the same person (e.g. "Joe Biden", "The President").

CDCR is challenging because there are so many possible entities and thus O(n2) comparisons to make between candidates.

Approaches

Tasks

Keyword Extraction

Graph-Based Keyword Extraction

Graph-based approaches like TextRank allows the extraction of keywords + phrases based on their centrality to the semantics of the other words in the document.

Tasks

Relationship Extraction

Relationship Extraction (RE) is a task that is related to Coreference Resolution but with a focus on identifying relationships between entities.

In the following example:

James, the CTO at Filament AI, lives in the South of England.

We want to identify the following relationships:

(James, isCTOof, Filament AI)
(James, livesIn, England)

Approaches

Tasks

Federated Learning

Tasks

Large Scale Multi-Label Learning

The Keras website has a tutorial on how to do multi-label learning with a large number of labels:

Machine Learning with Limited Data

Machine Learning with Limited Data

Pattern Exploitative Training

PET or Pattern Exploitative Training

image-1649077362304.png

@article{schick2020exploiting,
  title={Exploiting Cloze Questions for Few-Shot Text Classification and Natural Language Inference},
  author={Timo Schick and Hinrich SchΓΌtze},
  journal={Computing Research Repository},
  volume={arXiv:2001.07676},
  url={http://arxiv.org/abs/2001.07676},
  year={2020}
}

@article{schick2020small,
  title={It's Not Just Size That Matters: Small Language Models Are Also Few-Shot Learners},
  author={Timo Schick and Hinrich SchΓΌtze},
  journal={Computing Research Repository},
  volume={arXiv:2009.07118},
  url={http://arxiv.org/abs/2009.07118},
  year={2020}
}
Machine Learning with Limited Data

Learning with Limited Data

Good machine learning is heavily dependent on good data. A few more good data-points is likely to be worth billions of model parameters.

However, sometimes we need to train models when data is limited. There are a number of strategies that we can try.

Zero-Shot and Few-Shot Learning

Β 

In Context Learning (ICL)

Synthetic Data Generation and Augmentation

DeBERTa Zero Shot

The DeBERTa zero-shot model is an NLP zero-shot classifier trained by Moritz Laurer and made publically available on HuggingFace

Explainability and Model Analysis

Explainability and Model Analysis

Explainability

Explainability is a big challenge in machine learning.

I wrote a blog post about the ELI5 library and how it can be applied to NLP models.

Introducing ML customers to explainability early on can be a great way to build trust. A colleague suggests using Streamlit tools to allow customers to play with models and understand the contribution different features have had to a particular decision.

Explainability and Model Analysis

Model Confidence Scores

Many ML classification models can provide a confidence score which tells the user how confident the model is that it has made the correct choice.

The values of these confidence scores and what constitutes a "good" or "bad" score can vary a lot depending on the type and behaviour of the model. We often get asked why a particular model only ever seems to be 20% confident when a different model gives 99% confidence. Here's why that happens.

Confidence vs Certainty

Confidence and certainty are related but distinct concepts. We want models to be confident that they are correct (a high score is allocated to one of the labels and a low score allocated to the remaining labels) but also we want it to be certain it is correct (we want it to rely on features/cues that lead to the actual correct outcome).

Neural networks are known to often be over-confident in their results but still incorrect due to the way that modern deep learning learns. The paper On Calibration of Neural Networks dives into this further.

In order for us to be able to trust confidence scores, models must also be well calibrated.

Confidence in Random Forest Models

Random Forest Models are made up of an ensemble of decision tree models which are trained based on randomly selected sub-samples of the full training set - allowing the trees to learn different feature priorities based on the variance in the data that they are "assigned".

A single decision tree model cannot easily tell you how confident it is - the data is passed in and the algorithm traverses the branches in the tree until it reaches a decision. Within the random forest, confidence is calculated by assigning each tree a "vote" on the outcome class and then working out the distributions of votes across the possible outcome classes as a percentage.

In scikit-learn decision trees[ do have confidence scores](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier.predict_proba) calculated as the proportion of each class that ended on a given leaf node during training

Say we train a random forest model containing 100 trees on a company sector/industry classification problem with 5 classes. In theory, some of the trees will learn to prioritise the most important features in the dataset. Likewise, we can assume that some of the trees will be trained on less representative sub-samples of the training data and will prioritise less discriminative features.

When we predict on an unseen data sample we might get an output like this:

We specialise in using AI to improve user experience for customers of high end grocery stores

35 Trees votes for "Consumer Goods"
25 Trees voted for "IT & Technology"
22 Trees voted for "Health & Beauty"
12 Trees voted for "Retail"
6 Trees voted for "Automotive Manufacturing"

I used 100 random trees in my model for easy maths, so we would say in this case that the model is 35% confident that this description is from a company in consumer goods.

Can We Calibrate Confidence in Random Forest Models?

Confidence calibration is a technique that allows us to more closely map the confidence of an ML model (via its decision function) onto the real life probability that a sample belongs to a particular class.

Confidence in Neural Networks

Neural classification models can have many different internal structures but tend to have a set of inputs that correspond to the feature vector of the task being learned (e.g. a sparse bag-of-words, a set of RGB pixel values or numerical sensor readings) and a set of outputs equal to the number of classes being predicted.

Activation functions in hidden layers can produce wildly different and un-normalised values depending on the inputs, random initialisations and what is learned (although we can use normalisation constraints in our learning to prevent individual weights from going too far).

The output of the model is therefore typically normalised using SoftMax which essentially takes a weighted average of the results - its a bit like saying "which output received a higher percentage of the overall signal propagated through the network?"

Can We Calibrate Confidence in Neural Networks?

Argilla

Argilla is a data annotation tool with an API that allows you to use external models to automatically suggest labels and carry out active learning.

Resources

- Argilla Few Shot Learning Tutorial - warning some of the code in this notebook is wrong

LLM Models

A list of models

LLM Models

Gemini 2.5 Series

Developer/Trainer Google
Homepage https://deepmind.google/models/gemini/pro/




LLM Models

Anthropic

Anthropic is a silicon valley startup and AI company that develops and sells LLM models and LLM-based products and services. They also developed the Model Context Protocol for passing information between models.

Key Information

Relationship to Other Models

Anthropic are one of the earliest competitors to OpenAI and their Claude Sonnet and Opus series models were early competitors to GPT-4.

Claude Models

The Claude model series includes several versions:

Claude 3 Series

Other Models

Related Content

LLM Models

Claude 4

Claude 4 is a large language model developed by Anthropic.

Key Features

LLM Models

Anthropic Claude 3 Opus

Overview

Claude 3 Opus is Anthropic's most powerful model, designed for highly complex tasks that require the highest levels of reasoning and understanding.

Capabilities

Performance

Use Cases

flowchart LR

A[Hard] -->|Text| B(Round)
B --> C{Decision}
C -->|One| D[Result 1]
C -->|Two| E[Result 2]
LLM Models

Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?

Title: Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?

Authors: Thibaud Gloaguen, Niels MΓΌndler (ETH Zurich), Veselin Raychev, Mark MΓΌller, Martin Vechev (LogicStar.ai / ETH Zurich)

Published: June 2026 β€” arXiv:2602.11988

Link: https://arxiv.org/abs/2602.11988

Summary

A widespread practice in software development is to tailor coding agents to repositories using context files (AGENTS.md, CLAUDE.md), strongly encouraged by agent developers. This paper presents the first rigorous evaluation of whether such context files actually improve task completion performance.

Key findings:

The authors created CTX BENCH, a new benchmark of 138 real-world Python tasks from 12 niche open-source repos with developer-committed context files, complementing SWE-Bench Lite evaluation.

Conclusion: Context files should only contain non-standard coding practices not already in the README. LLM-generated ones are not worth it yet. Any attempts to improve performance should be rigorously evaluated before deployment.

SLMs

Specialised and Small Language Models (SLMs) including information on alternative approaches to transformers

SLMs

Less is More: Recursive Reasoning with Tiny Networks

Paper: https://arxiv.org/html/2510.04871v1Β 

Abstract

Hierarchical Reasoning Model (HRM) is a novel approach using two small neural networks recursing at different frequencies. This biologically inspired method beats Large Language models (LLMs) on hard puzzle tasks such as Sudoku, Maze, and ARC-AGI while trained with small models (27M parameters) on small data (∼ 1000 examples). HRM holds great promise for solving hard problems with small networks, but it is not yet well understood and may be suboptimal. We propose Tiny Recursive Model (TRM), a much simpler recursive reasoning approach that achieves significantly higher generalization than HRM, while using a single tiny network with only 2 layers. With only 7M parameters, TRM obtains 45% test-accuracy on ARC-AGI-1 and 8% on ARC-AGI-2, higher than most LLMs (e.g., Deepseek R1, o3-mini, Gemini 2.5 Pro) with less than 0.01% of the parameters.

SLMs

Mistral Small 3.2

Mistral Small is a 24B param LLM that

Running in Ollama

ollama pull hf.co/gabriellarson/Mistral-Small-3.2-24B-Instruct-2506-GGUF:Q4_K_M

References

SLMs

Hierarchical Reasoning Model

Paper URL: https://arxiv.org/pdf/2506.21734Β 
Code Repo:Β https://github.com/sapientinc/HRMΒ 

HRM is an alternative to transformer architecture that is better able to reason. It outperforms transformer-based LLMs at ARC-AGI2 with only 27M parameters.

Training a 27M Parameter Model with 1000 Examples

In the paper the authors refer to the fact that they only use between 1000 and 10,000 examples for specific problem domains:

This may seem quite low considering that this is a 27M parameter neural network and it seems likely that the network would be underfit after so few examples. The authors provide some additional clarifications around this point:

  1. Data augmentation is used in order to functionally boost the size of the training set.
  2. The authors use deep supervision to augment the training process (rather than relying on back-propagation alone).
  3. The problem domain is simpler than for language - particularly for things like Sudoku and ARC-AGI - these are structured grid type problems.
SLMs

Gemma 4

Gemma 4

Released March 31, 2026 by Google DeepMind. Apache 2.0 licensed. Multimodal (text + image, audio on small models).

Model Sizes

Model Type Effective Params Context Modalities
E2B Dense 2.3B (5.1B w/ embeddings) 128K Text, Image, Audio
E4B Dense 4.5B (8B w/ embeddings) 128K Text, Image, Audio
26B A4B MoE 3.8B active / 25.2B total 256K Text, Image
31B Dense 30.7B 256K Text, Image

The 26B A4B is the standout β€” a MoE model that runs almost as fast as a 4B model despite 26B total params. The E2B/E4B use Per-Layer Embeddings for on-device efficiency.

Local Running Options

  1. Ollama β€” ollama run google/gemma-4 (all sizes). Easiest one-command setup.
  2. llama.cpp β€” GGUF quantized versions available on Hugging Face. Good for CPU/GPU hybrid inference.
  3. vLLM β€” For higher-throughput server deployment. Supports the native HF safetensor weights.
  4. LM Studio β€” GUI-based, supports GGUF formats. Good for desktop use.
  5. Hugging Face Transformers β€” Direct Python API. Full precision or QLoRA fine-tuning.

Hardware Requirements (rough)

The 26B A4B is generally considered the sweet spot for local use β€” frontier-level benchmarks (82.6 MMLU Pro, 88.3 AIME) with ~4B active parameter compute cost.

All models are on Hugging Face under google/gemma-4-*.

Claude Code

Using Claude Code with LiteLLM

As per: https://docs.litellm.ai/docs/tutorials/claude_responses_api

export env vars corresponding to your litellm proxy instance:

export ANTHROPIC_BASE_URL="http://0.0.0.0:4000"
export ANTHROPIC_AUTH_TOKEN="$LITELLM_MASTER_KEY"

Using Claude Code with LM Studio

ReferenceΒ 

Start the server:

lms server start --port 1234

Point Claude Code at local instance:

export ANTHROPIC_BASE_URL=http://localhost:1234
export ANTHROPIC_AUTH_TOKEN=lmstudio

Github Official Plugin

Reads PAT from GITHUB_PERSONAL_ACCESS_TOKEN env var. When PAT expires, update it in zshrc or wherever yours is stored.

Github MCP Only

Public project here: https://github.com/github/github-mcp-server

Generate a PATΒ 

Enable the tool in Claude Code

 claude mcp add --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer <token>"


OpenCode

OpenCode is a tool for AI driven development. It allows you to set up a web-ui or a TUI and talk to an agent. You can also review outputs and directly run bash commands.

OpenCode with LiteLLM

LiteLLM provides a way to connect your environment to multiple different models and model providers without giving OpenCode a bunch of different api keys. You can also closely track OpenCode-specific spending from one admin portal.

Configure LiteLLM

Firstly, add any models that you want to interact with, this might be via openrouter, OpenAI, Anthropic or local models. You'll want to keep track of the Public Model Name as that will be the name we pass on to OpenCode.

image.png

We'll add a new virtual API key so that we can provide this to OpenCode and track spending. You might also want to set a max budget which resets after N days.

image.png

Β 

Configure OpenCode

Open the settings panel in the web UI and select "Providers" and click "Connect" next to custom provider.

image.png

Fill out the information from Litellm including the API base (remember to append /v1) and the API key you generated

image.png

Evaluating AGENTS.md: Are Repository-Level Context Files Helpful for Coding Agents?

Paper: 2602.11988

Authors: Thibaud Gloaguen, Niels MΓΌndler, Mark MΓΌller, Veselin Raychev, Martin Vechev

Published: February 2026

Summary

This paper evaluates whether repository-level context files (like ) actually help coding agents perform better on real-world software engineering tasks.

Key Findings

Performance Impact

Cost Impact

Behavioral Changes

AGENTBENCH

The authors created a new benchmark called AGENTBENCH consisting of:

AGENTBENCH complements SWE-BENCH LITE (which uses popular repositories without context files).

Experimental Setup

Coding Agents Evaluated

Datasets

Settings Evaluated

  1. NONE: No context files
  2. LLM: LLM-generated context files (using agent-developer recommendations)
  3. HUM: Developer-provided context files

Key Insights

1. Context Files Make Tasks Harder

Instructions in context files increase reasoning tokens by 14-22%, suggesting tasks become more complex.

2. Context Files Are Redundant

When documentation files are removed from repositories, LLM-generated context files actually improve performance by 2.7% on average.

3. Stronger Models Don't Generate Better Context Files

Using GPT-5.2 to generate context files improves SWE-BENCH LITE performance by 2% but degrades AGENTBENCH performance by 3%.

4. Context Files Encourage Exploration

Agents use more repository-specific tools (e.g., , ) and run more tests when context files are present.

Recommendations

  1. Omit LLM-generated context files for now, contrary to agent-developer recommendations
  2. Include only minimal requirements in context files (e.g., specific tooling to use)
  3. Human-written context files should describe only essential information
  4. Future work: Improve automatic generation of concise, task-relevant guidance

Limitations

Conclusion

Context files have only a marginal effect on coding agent behavior. While they encourage broader exploration and instruction following, they don't provide effective repository overviews and often make tasks harder. The authors recommend omitting LLM-generated context files and including only minimal requirements in human-written ones.

Tags: #agents #context-files #evaluation #SWE-bench #LLM-agents

AI Agent Resources

Resources, tools, and frameworks for AI coding agents and autonomous AI systems

AI Agent Resources

AI Agent Resources

This page collects useful resources for effective agentic engineering β€” tools, frameworks, and skills that make coding agents more capable, reliable, and productive.

Each entry is something worth integrating into your agent workflow, whether as a skill, plugin, or standalone tool.

Impeccable

URL: impeccable.style Β· GitHub

Stars: 27k+

A design-focused AI agent skill that teaches your coding agent how design works. It loads seven reference files on every prompt (typography, color, motion, spatial, interaction, responsive, UX writing) to give your AI a shared design vocabulary.

Key features:

Use case: When your AI agent needs design-aware output β€” typography, color systems, spacing, motion, responsive layouts, and UX writing.

Ultrapowers

URL: github.com/danduma/ultrapowers

Stars: 1

A framework that adds a Product Manager role to your coding agent. It introduces PM-style thinking β€” requirements, prioritization, scope management β€” into the agent workflow.

Key features:

Use case: When you want your coding agent to think more like a PM β€” scoping work, managing priorities, and making product decisions before coding.

Playwright CLI

URL: github.com/microsoft/playwright-cli

Stars: 10k+

Microsoft's official CLI for common Playwright actions. Record and generate Playwright code, inspect selectors, and take screenshots β€” all from the command line.

Key features:

Use case: When you need to record browser interactions, generate Playwright test code quickly, or inspect selectors without opening the full Playwright Inspector.

Taste Skill

URL: tasteskill.dev Β· GitHub

A design-system skills pack for AI coding agents focused on producing premium, distinctive frontend output β€” the creator's pitch is "escape the generic AI slop." It ships as a collection of SKILL.md files that plug into any agent supporting the skills protocol (Cursor, Claude Code, Codex, Gemini CLI, v0, Lovable, OpenCode, and more).

Key features:

Use case: When you want your AI agent to produce frontend output with a cohesive, high-end visual identity rather than generic default styling. Install the skill pack and pick the aesthetic that matches your project.

Layers

URL: layers.jamiemill.com Β· GitHub

A design-thinking skills pack by Jamie Mill that gives AI agents a structured framework for product design decisions. Rather than jumping straight to screens, Layers walks the agent through seven layers of product design β€” from surface-level visuals down to user needs, domain knowledge, and observed behavior.

The Seven Layers:

  1. Surface β€” visual design, colors, typography
  2. Interaction structure & flow β€” navigation, states, edge cases
  3. Conceptual model β€” objects, relationships, mental models
  4. Product & service strategy β€” outcomes, bets, positioning
  5. User needs β€” job stories, priorities, pain points
  6. The domain β€” terminology, constraints, expertise
  7. Observed behaviour β€” analytics, usage patterns, real-world data

Key features:

Use case: When you're starting a new feature or redesign and need your AI agent to think through the right design decisions before touching a pixel. Especially valuable when your team can't agree on direction β€” the framework surfaces what you're actually disagreeing about.

Superdesign

URL: app.superdesign.dev

An AI-powered design tool that generates production-ready website designs from text prompts, screenshots, or existing URLs. It combines a prompt library with AI generation and offers Cursor/Claude Code/VS Code integration for seamless handoff to development.

Key features:

Use case: When you need rapid design exploration or want to generate a polished landing page / component library from a prompt. Great for early-stage projects, design sprints, or when you want to quickly validate a visual direction before committing to implementation.

Archify

URL: github.com/tt-a1i/archify

Stars: 523 Β· Forks: 33

A Claude Skill that generates polished architecture, technical workflow, sequence, data-flow, and lifecycle diagrams from plain-English descriptions. It outputs a single self-contained HTML file you can open in a browser, toggle between dark/light themes, copy to clipboard, or export at high resolution (4Γ— PNG, JPEG, WebP, SVG).

Key features:

Use case: When you need to quickly visualize system architecture, data flows, or technical processes and want a clean, exportable diagram without opening a drawing tool. Especially useful in the middle of coding sessions when you need to document or share a design.

Vikunja CLI

URL: github.com/jo-nike/vikunja-cli

Stars: 1 Β· Forks: 1

A command-line interface for Vikunja, the open-source to-do and project management application. All output is JSON, making it easy to integrate with scripts and other tools.

Use case: When you want your agent to interact with Vikunja task lists programmatically β€” creating, querying, updating, and completing tasks via a CLI that outputs structured JSON for reliable parsing.

The Kehoe Rule

Summary of Bruce Lanphear's Article: "Artificial Intelligence and the Kehoe Rule"

This page summarizes Bruce Lanphear's article on Substack, which draws parallels between historical toxic industries and artificial intelligence.

The Kehoe Rule

Lanphear introduces the Kehoe Rule: a regulatory pattern where powerful new technologies are allowed to spread widely while the burden of proof falls on demonstrating harm, rather than proving safety before deployment. Named after Robert Kehoe, the lead industry's dominant medical authority in the mid-20th century, who insisted that leaded gasoline should remain in use until opponents could prove it caused harm. ([Source: Lanphear, Hidden in Plain Sight])

Historical Origins

Lanphear (a public health researcher who has spent his career studying toxic chemicals) writes that he was listening to Ezra Klein's podcast episode "The A.I.s Are Already Out of Control" featuring Helen Toner when the connection struck him. He notes that:

The Pattern Across Industries

Lanphear notes that corporations created useful, profitable products in each case. The trouble began when evidence of harm emerged: companies questioned the science, magnified uncertainty, funded more studies, hired experts and lawyers, lobbied regulators, and delayed restrictions. Too often, they concealed what their own scientists had discovered.

"The people making those decisions were not monsters. The corporation did not need monsters. It needed people to do their jobs."

Human Cost (cited sources)

Lanphear cites:

Lanphear's Core Argument About AI

Lanphear draws the parallel: companies developing AI are spending record sums to shape the rules that will govern them. Their views deserve to be heard; they understand the technology better than most lawmakers. But developers with a financial or institutional stake in rapid deployment should not be the primary arbiters of how much evidence of safety is enough, which risks are acceptable, or when development should slow.

He notes that AI can improve and spread around the world in weeks (vs. decades for lead/asbestos), so society may have far less time to detect a mistake before it becomes entrenched.

In July 2026, 1,386 employees of leading AI companies signed "Pacing the Frontier", asking the U.S. government to support an international effort to develop technical and governance tools needed to control the pace of frontier AI development β€” essentially asking to reverse the Kehoe Rule.

His conclusion: "The lesson is not that corporations are evil or that artificial intelligence must be stopped. It is that society should not confuse innovation with permission."

Comments on the Article

Lanphear's article received several comments, including one that raises an important distinction about agency:

"But I do see an essential difference between AI and other products. Agency. Cigarettes and lead, and radios and even televisions, have no agency. They each have very active impacts... But the products have no ability to make their own decisions, and to take actions that no human can comprehend. AI has both such abilities."

The commenter recommends Yuval Noah Harari's book Nexus (on the history of informational technology) and a NYT essay proposing: shut it all down right now, create oversight agencies like the NTSB, create monitoring agencies, and create a kill switch.

A Counter-Perspective on "AI Agency"

The comment above raises a point worth addressing directly. The claim that AI systems possess agency β€” autonomous motivations that no human can comprehend β€” is not supported by how these systems actually work.

LLMs are next-token predictors. They are facilitated by their harnesses, prompted by users, and deployed by corporations with clear commercial incentives. They have no goals of their own, no desires, no hidden intentions. The claim that AI systems can "pursue goals in ways creators never anticipated" conflates emergent behavior (which is explainable through the training process and prompt context) with agency (which implies autonomous intent).

This framing appears to be driven by effective altruism circles and Silicon Valley's more alarmist voices, which have a vested interest in portraying AI as an existential threat. This narrative serves certain funding priorities and institutional agendas far more than it serves accurate understanding of the technology.

Real Harms: Present-Day and Documented

The real harms from AI are not science fiction β€” they are concrete, measurable, and happening right now. Below is a synthesis of evidence from peer-reviewed research, government reports, and independent investigations.

1. Erosion of the Commons

2. Environmental Impact of Data Centres

3. Psychological and Sociological Impacts of Chatbots

4. Misinformation at Scale

5. Job Displacement in Knowledge Work

6. Centralization of Power

Lanphear's Proposed Solutions: Preventive vs. Reactive Governance

Lanphear contrasts two approaches:

Reactive Governance Preventive Governance
Waits for harm, then struggles to contain it Sets safeguards before widespread deployment
Post-facto regulation Requires independent testing and monitoring
Hard to control entrenched technology Makes developers report failures
Gives public institutions power to slow or stop a technology when warning signs appear

Sources & Further Reading

Bruce Lanphear's Article

Historical Context

Commons Erosion

Environmental Impact

Psychological/Sociological Impacts

Misinformation

Job Displacement

Centralization