Summary of "How to Make Claude Code Better Every Time You Use It (50 Min Tutorial) | Kieran Klaassen"

High-level takeaway

50-minute deep demo of “compound engineering”: a workflow and Claude/Claude Code plugin (built by Kieran) that helps Claude-based agents improve each run by capturing learnings and codifying them into the repo.
Main idea: treat AI work like an iterative engineering loop — plan → work → assess/review → codify/compound — so subsequent runs are higher-quality and lower-friction.

Compound engineering (philosophy)

Compound engineering = capturing mistakes, decisions, and project norms and storing them in the repo so the agent “learns” and future runs improve.

Four-step loop: 1. Plan — research and produce a grounded plan against your codebase and public resources. 2. Work — execute the plan (generate code, tests, infra changes, artifacts). 3. Assess / Review — run automated reviewers (security, architecture, simplicity) and QA. 4. Codify (Compound) — write the lessons and decisions back into repo docs/skill files so future plans incorporate them.

What Kieran’s plugin/flow does (features & commands)

Plugin: “compound engineering” plugin for Claude Code (open-source on GitHub). Install it in your repo to use the flows.
Primary slash-command flows demonstrated:
- workflows plan <description> — generates a research-backed, code-grounded plan.
- workflows work <plan> — runs implementation steps (creates branches, edits code, writes tests).
- workflows review — runs automated reviews from multiple perspectives.
- triage — conversational walkthrough of review findings and lets you pick actions.
- resolve to-do parallel — automatically resolve multiple to-dos and open a PR.
- playwright test / test and play — writes and runs Playwright end-to-end/browser tests.
- LFG (one-command end-to-end) — runs the entire loop (plan, work, test, review, produce marketing assets, create PR) and can run unattended for extended periods.
UI/UX:
- CLI-first; sessions can be pushed to the cloud/web app and resumed on other clients (example: amp % pushes session to cloud).
- Automatically creates artifacts (tests, screenshots, screen recordings, marketing videos) and attaches them to PRs.
- Writes persistent files into the repo (e.g., docs/, architecture decision records, cloth.md) so those items become part of future prompts.

Technical capabilities demonstrated

Grounded planning:
- The plan mode analyzes your actual codebase (frameworks, versions), searches external best-practice resources, and synthesizes a plan.
- Can run sub-agents (parallel agents) for specialized research tasks (framework researcher, best-practices researcher).
Playwright-based browser automation and testing:
- Opus 4.5 + Claude Code generates Playwright scripts, controls a browser, interacts with UI, reads console logs, and can log into external services (e.g., Gmail) to perform real integration tests.
- Can screen-record flows and auto-upload videos to attach to PRs.
Automated testing + immediate fix loop:
- If tests fail, the flow can modify code and re-run tests iteratively.
Review agents:
- Automatic reviewers produce prioritized to-dos (P1/P2/P3) and place items in a to-do directory in the repo.
- triage walks the developer through fixes and can apply them automatically.
Skills:
- On-demand contextual documents/scripts/tools (skills) the agent can pull in (examples: agent-native architecture skill, image-generation skill).
- Skills act as just-in-time context/integrations. Best practice: avoid hand-writing huge skill contexts unless needed; use skill creation helpers.
Sub-agents:
- Run tasks in isolation or in parallel to avoid flooding the main context; useful for research and parallelizable work.
Permissions:
- “Dangerously skip permissions” mode (alias CC in Kieran’s setup) disables interactive approvals — useful for long unattended runs but requires careful sandboxing.
- Alternatively, you can configure repo-level permissions so Claude remembers them.

Practical tips, trade-offs, and cultural points

Tokens / cost:
- Large planning and research sessions are token-heavy (tens of thousands of tokens). Requires a large-model subscription for heavy use.
- Kieran argues it’s cost-effective relative to developer time for real product work.
Start with planning:
- Invest time in the Plan stage to reduce rework; codify decisions early to avoid costly mid-implementation changes.
Trust & verification:
- Use test and review stages to maintain safety and correctness. Decide where automatic changes are acceptable vs. where human approval is required (CI/PR gates).
Use the repo as state:
- Documentation files (e.g., cloth.md, docs/, architecture decisions) become persistent prompt context for future runs.
Use the plugin as a scaffold:
- Adopt and tweak Kieran’s plugin (commands, agents, skills) or build your own flows. Kieran estimated ~1 year to build the demo system.

Guides / step-by-step demo flow shown

Install plugin and dependencies (demo shown in Warp terminal).
workflows plan — provide a voice/text description of the feature; inspect the generated plan.
Optionally “deepen plan” to pull in more context/resources or modify the plan (e.g., consolidate multiple setting tools into one).
workflows work — run implementation, answer clarifying questions, let it code and write tests.
Run playwright test — execute browser automation tests, capture console logs, record a video.
workflows review / triage — run multi-perspective reviews and accept/reject fixes.
resolve to-dos → PR created automatically; optionally auto-generate marketing video and changelog.
Demonstrated sharing a session between CLI and web app (amp % to push) and continuing on phone/web.

Tools & integrations mentioned

Claude / Claude Code (Opus 4.5)
Playwright (browser automation & recording)
Warp terminal (CLI environment)
Typora (Markdown viewer; optional)
GitHub / Linear (issue/ticket integrations)
Gmail (demo login for integration testing)
Granola (sponsor; meeting notes app)
Plugin repository (compound engineering plugin on GitHub)

Limitations & warnings

High token usage for deep planning/research; needs an appropriate subscription tier.
Danger of unsafe operations if running with permissions-skipped mode on an unsafe machine — sandboxing recommended.
Skills and sub-agents may require careful prompt/metadata formatting to trigger reliably in some interfaces.

Resources & how to get started

Install the compound engineering plugin in your repo and run the example slash commands.
Typical flow: workflows plan → inspect & iterate → workflows work → playwright test → workflows review → triage → resolve to create PRs.
Create and maintain cloth.md / docs/ and architecture decision records to codify project-specific learnings for future runs.
Explore or modify the plugin’s skills, agents, and commands to match your stack (iOS, Go CLI, etc.).

Main speakers / sources

Kieran Klaassen (Kieran) — CTO at Kora, creator of the compound engineering plugin; demoed the full flow.
Interviewer / host (YouTube channel host — referred to as Peter) — guided the demo and asked questions.