Maddy Zhang demonstrates five skills for Claude Code, Anthropic’s terminal-based coding assistant. A music-box application and the Kibana codebase provide concrete examples. The ten-minute walkthrough shows how reusable instructions can shape design, requirements, tests and review, with a custom skill at the end for work the existing catalog does not cover.

Package a workflow so the agent can reuse it (01:08)

  • A skill combines a Markdown instruction file with optional supporting references. Its name and description identify when it applies; the body gives the steps to follow.
  • Documentation, examples and style guides can live alongside the instructions and load when needed. The skill carries a repeatable process into a new session.
  • Zhang separates this process knowledge from the model itself. Her demonstrations focus on changing how the assistant approaches a task, rather than simply asking for more code.

Give interface work a deliberate visual direction (02:04)

  • The official frontend-design skill guides layout, visual hierarchy and design choices. Zhang uses it on a music-box app where users compose songs on a cylinder or upload MIDI files.
  • She starts in plan mode. The agent reads the project, asks questions and proposes an implementation before she approves changes.
  • A live desktop preview lets the agent inspect the rendered page and take screenshots. Zhang can iterate while watching the actual interface. She also points to checkpoints for returning to an earlier code state after an unwanted change.

Resolve requirements against the existing codebase (04:30)

  • Matt Pocock’s grill-with-docs interviews the developer about a proposed change while consulting project documentation and existing concepts. Zhang uses it before unfamiliar or large-scale work.
  • Her example adds a plugin for tracking dashboard activity in Kibana, Elastic’s data exploration interface. The agent explores existing plugins and source files before asking design questions.
  • Questions about where events belong are answered against the repository’s current structure. The process is meant to expose conflicting definitions and dependent decisions before implementation makes them costly to change.

Make the tests fail before implementing the feature (06:00)

  • Test-driven development, or TDD, follows a failing test with an implementation and then refactoring. Zhang warns that writing tests after the code can simply confirm the implementation’s own assumptions.
  • For a song-sharing button, her TDD workflow first creates tests, including edge cases, and runs them while the feature is still absent. The failures are expected.
  • The agent then writes the implementation and reruns the tests. Zhang shows them passing, followed by a coverage check. The important sequence is visible failure before the fix.

Review assumptions as well as changed lines (07:00)

  • A code-review skill examines a Kibana change involving authentication and request-forgery protections. Zhang walks through its generated report in severity order.
  • One reported concern is a security assumption enforced by an upstream gateway rather than the changed code. A development or staging environment without that gateway could behave differently.
  • Other findings concern constrained credential values, missing diagnostic logs, tests and maintainability. These are the reviewer’s reported findings in the demonstration, not independently confirmed vulnerabilities.

Turn a repeated check into a custom skill (08:42)

  • The official skill-creator interviews Zhang about an Elasticsearch query validator, then packages the requested workflow for later sessions.
  • She specifies the current branch’s diff as input, checks for query syntax and deprecated constructs, and includes guidance on expensive aggregations. She also chooses Markdown findings and permits fixes.
  • The example shows why scope and output format belong in the instructions. A reusable validator needs to know both what to inspect and what actions it may take.

Caveat: Anthropic sponsored the video; these demonstrations do not measure productivity gains or establish that generated security findings are correct.