> **Lab — what I'm working on — Silou**
> Canonical: https://silou.dev/lab
> Generated: 2026-07-19 — markdown twin of the HTML page (the HTML is the source of truth).

# What I'm working on

*Lab*

Honest work-in-progress — instruments I'm building and notes I'm refining. None of this is a finished flagship, and I won't pretend it is. It's here so you can watch how I think and build in the open.

## In progress

### AI Usage Card *(shipped · in use)*

My own skill: a prompt you run in your own Claude Code that measures how you actually operate the model — your level (L0–L5), your ≈ Cherny adoption step, your one next unlock. 100% local, ~2 minutes. Live at [silou.dev/pulse](https://silou.dev/pulse/); the story is in the working note below.

### cLens *(open-source · MIT)*

A local-first, zero-dependency Claude Code observability instrument that turns invisible agent behavior into auditable signal — it captures and analyzes every agent session. Terminal-first today, web front-end in progress. Public and clickable: [github.com/silouone/clens](https://github.com/silouone/clens) ([npm @silou/clens](https://www.npmjs.com/package/@silou/clens)).

### Software factory *(private · building)*

An autonomous dev-workflow system I'm building for my own work: typed tickets in, human-reviewed pull requests out — agents and deterministic code in the middle, humans at both ends. Spec-driven, and instrumented end-to-end by [cLens](https://github.com/silouone/clens) + OpenTelemetry on every run. Private today; it's the working proof behind "run it without you" on the [home page](https://silou.dev/).

### Personal knowledge hub *(daily use)*

A knowledge system I run for myself — linked notes, spaced repetition, and agents working over a local database served through MCP. Built for my own use, not productized; useful as a testbed for patterns I later teach.

## Working notes

Short, evolving notes on agentic engineering — the thinking behind the [method](https://silou.dev/approach). Each is becoming its own piece; the drafts live behind the titles.

### [Behavior over kit: what your Claude Code setup says about you](https://silou.dev/writing-behavior-over-kit)

Installed tools tell you almost nothing — the level lives in behavior. The story of the AI Usage Card: why I built it to calibrate a talk for a room of ~50 engineers, and how a level becomes a path instead of a horoscope.

### [The harness, not the prompt](https://silou.dev/writing-harness-not-the-prompt)

The next dev skill is engineering the system around the model — context, the agentic layer, hooks, offloading, observability — not wording the request. Teams that optimize only the engine leave most of the leverage on the table.

### [plan → build → review](https://silou.dev/writing-plan-build-review)

The loop I work by: scope the work, let the agent build against that scope, then review — with evals so "it works" is measured, not a vibe. Underneath it, one rule: match each piece of work to the lightest layer that can carry it — inline, a command, an agent, or a packaged skill. Keeps the system legible instead of a pile of clever prompts.

### [Model-offloading & the price of lost confidence](https://silou.dev/writing-model-offloading)

When sending non-interactive work to a smaller or local model wins — and when the harness you need to trust its output costs more than the model you saved. The tradeoff is reliability, not just price.

### [What every team should know about LLMs](https://silou.dev/writing-llm-fundamentals)

The mental model that stops cargo-culting: tokens (models think in numbers, not words), the context window (why overstuffing it backfires), tools (why too many slow an agent down), and what an agent actually is — versus when you don't need one. The fundamentals that make everything above make sense.

### [Getting yourself out of the loop](https://silou.dev/writing-out-of-the-loop)

The end state isn't a faster chat — it's work that runs without you. Loop engineering plus scheduling (cron) turns a good harness into unattended runs you can trust: the agent does the job on a timer, and the hooks, evals, and observability are what let you step away.

## Prefer the live version?

The clearest read on how I work is a session on your own code.

[See sessions & pricing](https://silou.dev/sessions)