Concepts / Anthropic Plugin Development

Anthropic Plugin Development

A plugin is a self-contained package of prompts, tools, and configuration for one specific task.

  • Programming

Why a Plugin Makes a Stronger Claim Than a Résumé Line

Anyone who wants to show an employer that they can do forward deployed engineering work needs something concrete to point to. A résumé line saying you understand customer problems is easy to write and hard to verify. This article looks at one direct way to produce that evidence: building a plugin on Anthropic's platform. The source material presents this path as especially current, because Anthropic's Code with Claude conference in 2026 introduced enterprise plugin templates covering several industries, including HR, design, engineering, investment banking, equity research, private equity, and wealth management.

A plugin is attractive for this purpose because a well-built plugin is described as a microcosm of forward deployed engineering work. Even at small scale, it forces you to do the same kinds of thinking a deployed engineer does on a real customer engagement. As you read, keep one question in mind: what does a hiring reviewer need to see in order to judge the work without having to take your word for it?

Predicting the First Decision

What do you think happens?

When building a plugin, which decision should come first: identifying the job-to-be-done, or choosing the vertical?

  • Identify the job-to-be-done first

  • Choose the vertical first

Reveal answer
Answer:

Choose the vertical first

The vertical comes first because it constrains every later choice. A job-to-be-done only makes sense inside a domain, and the packaging only makes sense once you know which task it serves.

Tracing a Plugin from Vertical to Portfolio Entry

The source describes making a well-built plugin as a sequence of decisions rather than a single act of writing. Follow the stages in order. First, you pick a vertical, meaning a specific industry or domain you understand. Second, you identify a job-to-be-done, which is one concrete task that people in that vertical need to get finished. Third, you package the prompts, tools, and configuration that let the plugin carry out that task. Fourth, you make the package self-contained enough that someone else can install it and try it in about five minutes. The end point is a portfolio entry that a reviewer can evaluate.

Notice that the order is part of the lesson. Treating the plugin as a chain of decisions, rather than as a pile of prompts, is what turns a demonstration into something a reviewer can judge. The diagram shows the sequence the source describes; it does not add stages the source does not name.

What a Plugin Packages Together

Definition

A plugin is a self-contained package of prompts, tools, and configuration for one specific task.

The three parts have distinct roles. The prompts carry the instructions that tell the underlying model what to do for the task. The tools are the capabilities the plugin can call on while doing that work. The configuration holds the settings that shape how the package behaves. Because all three travel together, the plugin can be handed to someone else as one unit rather than as a set of loose files that only you know how to assemble.

The Outputs a Plugin Produces

Building the package is only part of the work. The source states that a plugin produces three things: a trace, an eval set against the plugin's task, and wrapper logic that makes the plugin reliable. Each shipped plugin therefore carries evidence beyond its installable parts. The source names the trace and the eval set without defining every detail of either, so treat them here as outputs you must be able to show, not as a fully specified format.

The diagram follows the source's wording. The source ties the wrapper logic to reliability and ties the evaluation evidence to the ability to defend the plugin. The word defensible is a reading of the source's emphasis on evidence, not a separate technical term. The diagram links each output to the plugin as a whole, because the source does not say which individual component produces which output.

Following One Plugin Through Each Stage

Worked example

Tracing a hypothetical HR plugin

A candidate wants a portfolio plugin in the HR vertical, which is one of the industries covered by the enterprise templates. Trace the plugin from vertical choice to a portfolio entry a reviewer can evaluate.

  1. 1
    Choose the vertical

    The candidate picks HR because they understand it. The vertical constrains every later choice, so the candidate does not pick a task outside this domain.

  2. 2
    Identify the job-to-be-done

    The candidate chooses one concrete HR task that people in that domain need to finish. The task is narrow enough to build and to demonstrate.

  3. 3
    Package prompts, tools, and configuration

    The candidate writes the prompts that instruct the model for that task, lists the tools the plugin can call, and sets the configuration that shapes its behavior, so all three travel together as one package.

  4. 4
    Make it self-contained

    The package is arranged so that someone else can install it and try it in about five minutes, without needing the candidate's loose files.

  5. 5
    Attach the outputs

    The candidate ships the trace, an eval set against the HR task, and the wrapper logic. These are the items the reviewer will check.

Result

A portfolio entry with a clear vertical, one defined task, a packaged plugin, and evaluation evidence a reviewer can inspect rather than simply take on trust.

Mistakes That Weaken a Portfolio Plugin

  • Common mistake

    Counting plugins instead of defending them

    What it looks like

    A candidate lists six plugins but can show evaluation evidence for none of them.

    Why it fails

    The source says eval evidence that lets you defend each plugin matters more than simply having many plugins in a portfolio.

    Do this instead

    Build fewer plugins and attach an eval set and trace to each one a reviewer can examine.

  • Common mistake

    Starting with packaging before choosing a vertical

    What it looks like

    A candidate writes prompts and tools first and only later decides which industry they serve.

    Why it fails

    The vertical constrains every later choice, and a job-to-be-done only makes sense inside a domain.

    Do this instead

    Choose the vertical first, then the job-to-be-done, and only then package the parts.

  • Common mistake

    Choosing a vertical you do not understand

    Why it fails

    The source describes the vertical as a specific industry or domain you understand, so a plugin in an unfamiliar domain is harder to justify.

  • Common mistake

    Leaving the package as loose files that only the author can assemble

Planning a Portfolio Plugin with Checkable Evidence

MEDIUM

Plan one portfolio plugin in a vertical you understand. Write down: (1) the vertical, (2) the single job-to-be-done, (3) the prompts, tools, and configuration you would package, (4) the trace you would show, (5) the eval set and the task it tests, and (6) the wrapper logic and what reliability problem it addresses. For each item, write one sentence describing how a reviewer could check it without relying on your word.

Hints
  • Start from the vertical, since it constrains every later decision.
  • The source names the trace and eval set without defining every detail, so state what each one must show rather than inventing a fixed format.
  • If a reviewer could not verify an item, rewrite it until they could.

Key Takeaways

  • An Anthropic plugin is a self-contained package of prompts, tools, and configuration for one specific task.
  • A well-built plugin follows a sequence: choose a vertical, identify a job-to-be-done, package the parts, and make the package installable and quick to try.
  • Each shipped plugin produces a trace, an eval set against its task, and wrapper logic that supports reliability.
  • A strong portfolio shows evaluation evidence for each plugin, because being able to defend each one matters more than the number of plugins.