AI Engineer Europe 2026
Skills at Scale
Loading slides…
Read the talk
Skills at Scale: From Repeated Instructions to Reusable Workflows
Build a repository-review skill, give it deterministic inputs and selective references, then carry the same techniques into evaluation, team distribution, creative tools and recurring automation.
From a talk by Nick Nisi and Zack Proser
Before you start: Familiarity with Git, Markdown and a terminal-based coding agent will help you follow the examples.
Explain the repository again
Open another terminal tab, switch repositories, and start another conversation with Claude. Before useful work begins, you explain the same things again: what matters in this project, how the team works, and which conventions the agent must follow. The problem is the repeated transfer of working context. AGENTS.md and CLAUDE.md help by supplying instructions such as using Vitest and pnpm each time a session starts.
Those instructions still need interpretation, and the agent can skip a requested step. A skill packages a recurring task so that the important requirements do not depend on someone remembering to repeat them. Zack Proser compares this to carrying DRY into agent-assisted work: the same reuse matters whether the collaborators are other engineers or multiple agents. Saved memory helps too, but repository instructions remain tied to a checkout, teammates need its updates, and global instructions can affect unrelated projects. Another requirement soon appears: how do you insert deterministic results into a nondeterministic conversation?
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give a repository review something specific to check
Repo Roast makes the difference concrete. Ask a generic agent to assess a repository and it may return broad praise with a few obvious suggestions. Give it the project's routing conventions, commit rules and expectations for README accuracy, and it has specific standards against which to inspect the code. The presenters suggest that roughly 30 lines of Markdown can be enough to establish that focused behavior. A skill can remain a small text file, or grow to include scripts and supporting material; its detailed instructions need only enter context when the task calls for them.
The comparison slide illustrates the intended change: generic reassurance becomes a structured assessment with concrete findings about large files, stale TODOs, documentation drift and contributor concentration. The goal is a repeatable method and report shape. Model choice and thinking settings still affect the answer, but the skill tells the agent what to examine and how to present its findings.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A skill is a package with a routing description
The entry point is SKILL.md, beginning with YAML front matter. Its name identifies the skill; its description tells the model when the skill is relevant. The surrounding folder can contain reference documents, executable scripts and images. Think of the description as a routing rule, with the body supplying the instructions after selection.
Start with a few constraints that make the result useful. For Repo Roast, those might require concrete evidence, precise code locations and a Git commit reference. The presenters favor these boundaries over a long narrative prescribing every move. A compact starting point is:
markdown
---
name: repo-roast
description: Analyze repository health when the user asks to roast a repo or review its maintenance problems.
---
Inspect the repository and produce an evidence-backed review.
- Never give a vague finding.
- Cite each code finding with its file, line and Git commit.
- Explain the consequence and a concrete next action.
- Do not invent a problem to make the roast more entertaining.
The constraints establish what a satisfactory answer must contain while leaving room for the agent to investigate.
The workshop repository supplies the Repo Roast baseline and presentation materials. Its exercise works across programming languages because Git history, repository structure and maintenance conventions are broadly applicable. Participants can make the tone serious or playful and add requirements from their own workplaces. The workshop's share.sh asks for a name and sends the submission to a KV store, allowing the presenters to retrieve and run it on screen.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Install, invoke and inspect
The presenters primarily use Claude, but discuss skills across Codex, Cursor and Claude Desktop as well. The reusable unit also serves nontechnical work. Nick Nisi describes helping WorkOS's recruiting team combine candidate information with Slack, Notion and recruiting-system data into consistently formatted reports. That report becomes a building block for subsequent work, and sharing the skill gives teammates a common way to produce it.
For the Claude Code setup demonstrated here, repository skills live at .claude/skills/<skill-name>/SKILL.md. The equivalent directory under the user's home directory makes a skill available across projects. Other tools use conventions such as .agents; the Vercel Skills CLI handles installation across tool-specific directories, including symlink-based placement.
The development loop is small:
- Edit and save the skill.
- Invoke it on a representative task.
- Inspect the output and whether the intended skill loaded.
- Revise the description or instructions and repeat.
A skill-creator skill can help critique the package and evaluate its behavior. For the first exercise, the description should make a request such as “Roast my repo” sufficient to select Repo Roast. Put conventions and prohibitions in the body, and be more prescriptive where the result genuinely must follow an exact requirement.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Supply the Git output instead of asking how to fetch it
Claude Code supports command-output injection using an exclamation mark followed by a backtick-delimited command. The harness executes the command and substitutes its output into the skill text before the model interprets it. This is a Claude Code preprocessing feature, rather than a guarantee of the portable skill format; Nick reports adding an extension to Pi for equivalent behavior. The workshop's stale-TODO example uses grep and shell pipes to supply repository evidence.
A Git report can use the same mechanism. Instead of asking the model to work out how to retrieve recent history, give it the history in the format you want:
markdown
## Repository evidence
Current working-tree status:
!`git status --short`
Latest ten commits:
!`git log -10 --format='%h %s'`
Use this evidence when describing repository activity.
Distinguish uncommitted changes from committed history.
For the same repository state, the commands provide a consistent starting point. The model can then interpret the evidence without repeatedly choosing commands, exploring Git documentation or returning a differently shaped result in another terminal session. Deterministic collection narrows the model's job to the judgment that follows.
Routing deserves the same specificity. A personal-blog image skill might apply only to a particular domain and require pixel art. A workplace image skill might use a different generator or fetch approved assets from S3. Put those distinctions in the descriptions, then ask the model when it would select each skill. This is useful feedback on ambiguous wording. It is less definitive for product capabilities: when Nick asks whether skills can call other skills, the agent performs a Claude Code lookup and returns a qualified answer.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Separate permanent preferences from shared procedures
An audience question sharpens the boundary between a rule file and a skill. In the setup Nick describes, CLAUDE.md or AGENTS.md enters context at session startup, so it should contain information that is broadly useful there. His global file is deliberately short: communication preferences and configuration directing Ideation artifacts into an Obsidian vault. A repository can add a one-line preference for pnpm; detailed testing instructions belong in a skill loaded while writing tests. Reviewing a week's work can reveal which repeated instructions deserve that treatment.
Sharing introduces a different problem. An attendee from an engineering organization worries about competing frontend skills, overlapping descriptions, review requests and instructions that become unnecessarily verbose after a model upgrade. The concern is prospective: anticipated maintenance costs are already blocking adoption. Zack suggests keeping personal modifications as local forks and periodically reviewing shared skills with the current model. WorkOS's public collection began as documentation organized into loadable units, and he reports that using those units through agentic tool calls improved his earlier generic RAG approach. Neither presenter claims to have solved the proposed original-author review and governance process.
WorkOS uses several distribution scopes: public skills, internal specialists such as authentication and developer experience, personal marketplaces, and skills committed to its monorepo. Versioned plugins provide a package boundary similar to an npm package, while an accessible internal Git repository can serve a Claude plugin marketplace. In the workshop, Nick has not used npx flags to select frontend-only skills. The current Vercel CLI documents --skill for selection and --agent for destinations. The broader packaging proposal is to document which marketplaces and team-specific packages to install during onboarding; repository ownership and review still remain underneath.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Test selection, task quality and context boundaries
For public skills, Nick describes repeated runs of the same task with and without the skill, graded against a rubric. A lower grade with the skill counts as a regression. His internal experiments are less formal. The thresholds and small improvements he recalls aloud are approximate; the useful mechanism is the paired baseline, repeated as models change.
Skill pickup is a separate test from answer quality. Overlapping descriptions can cause the wrong skill to load—or no skill at all. WorkOS includes relevant terms and acronyms in its routing descriptions. When the intended skill is already known, explicit invocation such as /WorkOS, or naming Superpowers' brainstorming skill, removes some selection ambiguity. For a required data-gathering step inside a selected skill, command preprocessing can remove the model's discretion about whether to gather that input.
Another audience question asks when to choose a sub-agent, a skill or a CLI. Nick's principal criterion for a sub-agent is a separate context window. In Ideation, review work can produce extensive intermediate reasoning and tool output. A sub-agent performs that work and returns a list of problems; the parent can correct them and repeat without absorbing the entire review transcript. The desired result is evidence of completion, rather than a premature declaration that the task is done. The exchange includes a documentation lookup about sub-agents using skills, but does not develop a complete decision rule for CLIs or agent teams.
For a default that inconsistently yields to a user override, the suggested diagnostic is to ask why the agent chose that default and how the instruction could make the intended override clearer. That can help generate revisions to test, but the workshop does not supply a reproducible precedence fix.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Use the same package for slides, images and reviews
The library discussion moves beyond repository maintenance. Nick shows a Slidev skill in the workshop repository, including its description and presentation use cases. Superpowers supplies planning and brainstorming routines; Remotion supplies a route from a prompt to a video. Zack uses Git history as input for weekly all-hands movies and describes a browser-based editing interface for trimming, cuts and fades.
Zack's image workflow wraps Google's Nano Banana in Python. He reports that most of his single-prompt image generations take under seven seconds. The next step passes the generated image to Veo, asking it to animate the scene. He reports roughly 30 seconds from a child-running-through-a-field prompt to a video, and about an hour making interstitials for a 32-minute film. These are timings from his own use; the reusable mechanism is the handoff from text to still image to animation.
Other experiments shorten different feedback loops. Zack describes biometric-based reminders, though he has not packaged that experiment as a skill, and a Superpowers interaction that offers browser mockups so he can choose a visual direction directly. Nick uses official Claude plugins and Obsidian skills, plus a review workflow that sends Claude's work to Codex and returns the findings without manual copying between terminal panes. Vercel's collection is another source they recommend exploring. The live Nano Banana image is received as an approximate match, and its style can be changed through the prompt, including Zack's preferred pixel art.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Ground the roast, then load only the references it needs
The first participant demonstration exposes a practical scope issue. After retrieving submissions through share.sh, Nick tries to apply Zack B's Repo Roast to the WorkOS CLI. The skill was loaded locally, and the run instead analyzes the workshop repository. While themed spinner messages mark its progress, Nick inspects the submission: Git and filesystem commands collect stale TODOs, churn hotspots and the largest files. Its central constraint is that every finding must be backed by script output or Git data.
Adding detail does not require placing every reference in the skill body. Progressive disclosure leaves a pointer and a condition: read TESTING.md when doing testing, or load the scoring rubric when producing scores. The same technique can work in a rule file, but it is especially useful inside a focused skill package.
markdown
## References
- When assessing tests, read TESTING.md.
- Before assigning repository scores, read scoring-rubric.md.
- Skip references unrelated to the current review.
The reference stays available without occupying the active conversation until it is relevant.
WorkOS applies this at a larger scale. A migration skill selects the relevant provider guide, such as the Auth0 migration material, rather than loading every migration path. Its skill router uses a reference map: installing AuthKit in Next.js points to workos-authkit-nextjs.md; another framework takes another route. The top-level file becomes an index of decisions about which knowledge to load.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn uncertainty and repeated friction into inputs
Ideation adds a gate before execution: assess whether the task is sufficiently understood, then ask questions about what remains unclear. The workshop version uses a self-reported confidence threshold of at least 95% before starting work. The presenters explicitly treat this number as a prompting device rather than a calibrated probability; the current Ideation workflow instead describes evidence-readiness gates without an aggregate numerical score. In the demonstrated approach, requiring an explanation of confidence can expose missing requirements that an unsupported number would conceal.
The useful behavior comes from the rubric and the ensuing dialogue. If the agent cannot explain the goal or success criteria, it uses AskUserQuestion to ask targeted questions, often with multiple-choice options and a recommended approach. Nick wants the agent to draw out information he has not yet expressed, rather than leave him to guess what additional context it needs.
Skill improvement follows a related loop:
- Build a working initial skill.
- Use it on real tasks for several iterations.
- Review outputs and locally saved JSONL conversation logs.
- Identify recurring mistakes, missing edge cases and repeated corrections.
- Change the smallest relevant instruction or script and evaluate again.
Nick's early meta-skill extracted reusable procedures from completed conversations. Repo Roast offers an immediate example: if Git exploration repeatedly goes wrong, replace it with the exact command whose output the review requires. The improvement starts from an already working baseline.
Zack looks for chores he resists doing every week. Switching from code to Slack and then creating Linear tickets was one such interruption. His automation reads requests, checks Linear for an existing ticket and creates one only when needed, letting him remain focused on the coding task. When asked for a ready-made meta-skill, he suggests asking skill builder to inspect the workflow and supplying connector boundaries, such as the Slack channels and direct mentions that matter. Nick tentatively identifies Claude Meta Skill and also describes revisiting a development conversation to recover forgotten anecdotes for a blog post.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep useful memory and justify repository scores
Persistent memory complements a reusable procedure. Nick describes Case, a Pi-based WorkOS developer-experience agent operating across React, React Router, Next.js and TanStack Start repositories. It keeps general and framework-specific memory.md files. End-of-task retrospectives identify wasted exploration and save useful commands for future runs. He has not completed a full background dreaming or pruning system, and is uncertain about the availability of Claude's discussed AutoDream feature.
Zack proposes using date-titled Obsidian notes for direct retrieval of a week's work and then writing consolidated memories. He also points to OpenClaw's daily journals and consolidated memory as a system he found useful in personal experimentation. The pattern is to preserve detailed records close to the work, then extract the parts worth carrying forward.
The second Repo Roast exercise brings that attention to evidence back into the review itself. Add workflow phases and a scoring rubric, then require an explanation for a low score. A commit-history critique should refer to the repository's actual conventions: conventional commits, for example, or a policy about merge commits. Put the detailed rubric in a separate file and load it for that assessment. The exercise slide also separates evidence, severity and actionability, with a rule to discard weakly evidenced findings. Participants can use setup.sh with checkpoint two to recover the exercise baseline.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A vague feature becomes a contract
Nick describes evaluation tooling that produces an HTML report comparing behavior before and after adding a skill, then opens the WorkOS CLI repository for a live Ideation run. The request is deliberately loose: add a fun /buddy command inspired by Claude Code's April Fool's feature. He issues it through Wispr Flow, a dictation tool the presenters use across focused text fields on the Mac. Their examples include technical filenames such as @userauthentication.ts and different tones for Slack versus email. Claude's fast mode is enabled for the demonstration.
Ideation first asks what kind of fun Nick means. He selects a visual gag, an ASCII art gallery and an Easter egg that is listed but subtle. The rubric covers problem clarity, goal definition, success criteria, scope boundaries and consistency; success criteria still need clarification. The displayed total rises from 90/100 to 96/100 after further clarification, including a zero-configuration preference. Those totals control the next workflow step; they do not measure the probability that the feature will succeed.
The agent then produces a contract for Nick to review. It defines success criteria, what is in and out of scope, future considerations and an execution plan. From the reviewed contract, Ideation can produce phase specifications that run with fresh context. This small feature needs only one phase. The demonstration reaches the contract and specification stage; implementation remains the next action.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Extend the analysis and move the package
Repo Roast can grow through additional evidence collectors:
- Contributor concentration: Use
git shortlogand code-area history to identify ownership concentration and possible bus-factor exposure. - Commit messages: Check messages against the project's conventions.
- Zombie branches: Find branches that remain without useful progress or closure.
- Late-night activity: Surface unusual commit times as a prompt for discussion.
- README reality: Compare documented claims with what the repository actually implements.
The final example matters because documentation can remain plausible long after it stops describing the product.
The package can then travel beyond the coding terminal: through Git-backed plugins, into Desktop workflows, or into another harness such as Pi. The presenters describe a Desktop handoff that zips the complete skill folder—including SKILL.md, scripts and references—and renames the archive from .zip to .skill. That makes a convenient transfer format, but does not solve versioning. They also discuss marketplace distribution for Desktop and explicitly warn against putting sensitive credentials in the archive.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Ship the skill inside a product—and test whether it helps
The WorkOS CLI turns the same knowledge package into an authentication installer. Its workos install flow detects a framework such as Next.js or TanStack Start, loads the appropriate guidance and adds AuthKit; Nick says it can also replace existing authentication. In the workshop architecture, the CLI embeds the Claude Agent SDK and takes its installation knowledge from WorkOS skills. Improving a skill therefore improves both the reusable instructions and the product that exercises them.
Nick describes npx workos install as a low-friction entry point, with model requests proxied using WorkOS's API token. He estimates roughly five minutes to get set up, including an account-claiming flow. Current CLI documentation describes that last step more precisely as provisioning a temporary unclaimed environment and later linking it to a WorkOS account.
Organizational procedures fit the same shape. A publishing skill can carry CMS instructions, tone and formatting conventions that would otherwise be buried in Notion or repeatedly sent over Slack. Code review, image styles and CI workflows can use similar packages. Zack again reports better query performance when his retrieval workflow loads WorkOS skills through agentic tool calls instead of relying on flat document chunks in a vector database, without supplying a quantitative comparison.
Adding instructions can make a capable model worse. Nick says his overly prescriptive Next.js installer skill interfered with work Claude Code already handled well. Nick recalls an approximately 30% drop in overall accuracy for that Next.js experiment, while qualifying both the figure and his homemade grading. No model, sample count or denominator is established for that recollection. He treats the eval like an Apple Watch: an imperfect instrument can still reveal a direction of change against a consistent baseline. The practical response is to remove dogma that harms outcomes, rather than assume a larger skill is a better skill.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Two API calls become an animation workflow
The animation demonstration begins with a previously generated Slack avatar. Zack hands it to the animation skill and asks for the obvious motion; the resulting Fallout-like figure holds and reacts to a ball of energy. The second example starts from a child running through a field. Its skill consists of Markdown and two Python scripts, with this sequence:
- Send the user's prompt to the image generator.
- Pass the resulting still image, together with an animation instruction, to Veo.
- Return the animation, including Veo's generated sound.
The handoff is the key: the second call consumes the first call's artifact. Zack repeats his roughly 30-second generation estimate and describes using the workflow for film interstitials.
Remotion demonstrates a different creative path. Nick asks for a promotional video about the WorkOS CLI, and the skill uses the CLI's behavior and output to construct it. A browser preview at localhost:3000 lets him inspect the result and request a concrete correction: replace the invented logo with WorkOS's actual logo. The preview updates as the agent changes the composition. Zack proposes extending this into CI/CD so a milestone could update documentation and generate a demo, but that integration is a future application discussed here.
The implementation can stay small. Zack describes the animation skill as roughly 30 lines of Markdown pointing to image and video scripts. Nick's Nano Banana variant instead develops a richer creative prompt and passes it to a TypeScript script that calls the image API. These examples divide the work cleanly: the model interprets intent and prepares arguments; a script performs the API operation. The same division can support a sales outreach procedure or a recurring customer report.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The finished roast still needs judgment
The final participant submission comes from Amy and Wolf from Ravenwolf. After correcting an initial selection mistake, Nick opens its latest version. It combines a blunt personality with constraints and audience detection, loading audience-guide.md through progressive disclosure. That keeps the main instructions manageable while making tone depend on who will receive the review.
The submitted skill gives the workshop repository 6/10. Its findings, read aloud, include an absent test suite, a 1,200-line monolith and duplicate Git identities for Zack. It also flags a hard-coded secret, which Nick disputes as not actually being a secret. The output shows the value of a specific review format and why a finding still needs interpretation: collecting evidence and assigning severity are separate judgments.
The next improvements should come from use. A skill creator can critique the instructions and run evaluations; isolated sub-agents can perform bounded reviews. Repeated clarification questions reveal information that could be supplied earlier. Repeated tool sequences reveal opportunities to consolidate collection into a script. Zack emphasizes preserving failed attempts and frustrating conversations, because they record exactly where the current workflow needs help.
Audience-sensitive disclosure adds one more use for repository evidence. Nick suggests reading git config user.email and checking contribution history to adjust a roast's tone. A long-time contributor may welcome a sharper critique, while someone with only a few commits may benefit from a gentler introduction. Commit history is a tentative familiarity signal, not proof that someone is a new hire.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Close the loop from Slack request to work
The last question returns to Zack's Slack-to-Linear automation and makes its operation concrete. He uses Claude Code with a Slack connector authorized through OAuth; he also says the workflow is possible in Desktop. The displayed MCP server list shows Slack and Linear connected. In Claude Code, he describes using /loop to check messages periodically—for example, every 15 minutes.
The recurring task has a simple decision rule: if a request has no corresponding Linear ticket, create one; if a ticket exists and the conversation adds requirements, update it. A second terminal session loops over Linear's task state and performs work. The connector supplies access, the skill supplies the procedure, and the loop supplies repetition. That is the workshop's final move: take a recurring interruption, define its inputs and decisions, and automate the cycle that keeps bringing it back.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Repo Roast starter materials, progressive checkpoints, attendee guides, sharing tools, and Slidev presentation sources.
Nick Nisi’s planning plugin turns an interview into reviewed contracts and implementation specifications. Its current workflow uses evidence-readiness gates.
Authentication installer and management CLI with framework detection and temporary environments for trying AuthKit.
Install and manage skills across agents, selecting individual skills and choosing project or global scope.
Further reading
- Writing my first evalsArticle
Nick Nisi explains installer pass rates, paired skill evaluations, domain-specific grading, and failures caused by the scorer itself.
Repository guide covering skill routing, reference documents, comparative evaluations, and human calibration.
A presenter’s account of the Repo Roast exercises, evidence-gathering scripts, and image-to-video skill demonstration.
Updates since the talk
Current documentation for skill discovery, invocation controls, command-output injection, supporting files, and isolated subagent execution.
Full transcript
Loading transcript…