Feature Library
With AI

Your agent reads the pitfalls before it writes a line.

Connect your coding agent to the library’s MCP server. It finds parts for the job and the frame budget, reads every pitfall and the guide, installs the files marked with your licence, and checks the build. Planning is free, with no account.

A real build, replayed

Watch an agent use the library.

Claude Code 2.1.325 with Claude Opus 5.5 got one brief and the library’s MCP server, nothing else. These are the calls it made, in order: 47 minutes in under a minute.

The brief

A storm watch for a small harbour town: the bay, live, is the background, with the weather now, the next 24 hours, warnings, the harbour's state and a 48-hour timeline over it.

The agent

Claude Code 2.1.325 · Claude Opus 5.5, in an empty folder. Its only way into the library: this server.

  1. Rules
  2. Plan
  3. Learn
  4. Install
  5. Build
  6. Check
47:12

First build done: 48 calls in 49 minutes. Then 2 review rounds, 58 minutes more

The library · 199 parts
48calls to the library
6playbooks read
97pitfalls read before a line
64files installed
Its frame: the whole page, as measured
2.3 of 16.7 ms at worst, the finished page measured
Every step, as a list
  1. 0:00 Connects to the library: 11 tools, and its rules as a resource initialize · tools/list
  2. 0:11 Reads the rules before anything else get_brief()
  3. 0:36 Starts from a tested kit: dashboard, in a refined tone get_kit("a weather desk for a harbour: a live GPU scene…")
  4. 1:07 Looks for sky with sun or moon by time of day and clouds, as a full-screen back… find_parts("sky with sun or moon by time of day and clo…")
  5. 1:07 Looks for ocean surface with waves whose height follows a forecast, whitecaps i… find_parts("ocean surface with waves whose height follo…")
  6. 1:08 Looks for rain and snow falling, slanted by wind, at a given rate find_parts("rain and snow falling, slanted by wind, at…")
  7. 1:08 Looks for fog and mist that hides distance when visibility drops find_parts("fog and mist that hides distance when visib…")
  8. 1:08 Looks for lights at night: lighthouse beam, harbour lamps, glow points find_parts("lights at night: lighthouse beam, harbour l…")
  9. 1:08 Looks for show each frame's cost part by part as slices of the 16.7 ms frame bu… find_parts("show each frame's cost part by part as slic…")
  10. 1:20 Reads 2 parts’ cards: 17 pitfalls, before writing a line get_part("physical-sky") · get_part("fft-ocean")
  11. 1:31 Reads 2 parts’ cards: 18 pitfalls, before writing a line get_part("rain-snow") · get_part("lit-height-fog")
  12. 2:17 Gets the wiring for its parts: 11 steps, in order get_recipe("storm watch weather desk: a live raw-We…")
  13. 2:28 Reads 6 playbooks: performance budgets, page shapes, placement and layout, accessibility baseline, motion and feel and layouts that never break get_playbook("performance", "page-shapes", "placement", …)
  14. 2:34 Reads 2 parts’ cards: 19 pitfalls, before writing a line get_part("capability-tiers") · get_part("day-timeline")
  15. 2:38 Reads 2 parts’ cards: 19 pitfalls, before writing a line get_part("quiet-charts") · get_part("kpi-tiles")
  16. 2:42 Reads 2 parts’ cards: 24 pitfalls, before writing a line get_part("chart-access") · get_part("effects-switchboard")
  17. 2:55 Installs the look it chose: 8 files install("atmos")
  18. 3:30 Installs Physical sky, Lit height fog and FFT ocean: 18 files, each marked with its licence install("physical-sky") · install("lit-height-fog") · …
  19. 3:48 Installs GPU capability tiers, KPI tiles, Effects switchboard, Day timeline and scrubber, Quiet SVG charts and Colour-blind safe charts and palettes: 38 files, each marked with its licence install("capability-tiers") · install("kpi-tiles") · …
  20. 3:49 Writes its own code for 15 minutes: the glue and the new centrepiece (no calls: building)
  21. 19:04 Checks its look’s settings: “Atmos, tuned”, 0 problems check_look("atmos")
  22. 19:05 Writes its own code for 10 minutes: the glue and the new centrepiece (no calls: building)
  23. 29:28 Writes its own code for 17 minutes: the glue and the new centrepiece (no calls: building)
  24. 46:50 Asks what to check before it may call the build done check()
  25. 47:00 Asks what to check before it may call the build done check()
  26. 47:11 Checks its look’s settings: “Atmos, tuned”, 0 problems check_look("atmos")
  27. 47:12 First build done: 48 calls in 49 minutes. Then 2 review rounds, 58 minutes more

Recorded on 17 November 2026: every call above comes from the server’s log of that run. The whole story, call by call.

The storm watch the agent builtWhat it built: the storm watchOpen it live, full page
What it does

Four calls, in order.

The server hands your agent the library’s rules first, then the tools below. It builds the glue and the new idea; the parts bring the hard-won details.

  1. 1

    Plan

    find_parts · get_kitFree

    It ranks parts for the job, the device and the milliseconds you can spare, or starts from a tested kit for the kind of build.

  2. 2

    Read

    get_partFree titles · in full with a licence

    Before it writes a line, it reads every pitfall and the guide: the mistakes someone already made so yours doesn’t.

  3. 3

    Install

    installWith a licence

    The part’s files, written unchanged into your project and marked with your licence, pinned to a version.

  4. 4

    Check

    checkFree

    The checks to run on the build, and whether it may be called done, with what is missing.

An estimate, not a measurement

What it saves, roughly.

The nine parts in that build, taken from the library, against the same nine built from nothing to the same standard. The left column comes from the recorded run; the right is our educated guess, with the assumptions below so you can judge it.

For the nine partsFrom the libraryFrom scratch our guess
Agent time3 min 48 s to find, read and install themmeasured6 to 15 hours of prompting, running and fixing
Tokens≈ 0.3 millionfrom the size of what it read and wrote≈ 1.5 to 4 million
Known pitfalls97 read before the first linemeasuredFound one at a time in testing, or by your users
Frame cost2.3 msthe whole page, at worstmeasuredUnknown until you measure it
How we got the numbers
  • From the library (measured): the run’s log shows the nine parts found, read and installed 3 min 48 s after its first call, 97 pitfalls on the cards it read, and 64 files installed. The whole page measured 1.3 to 2.3 ms of GPU a frame at 1920×1080.
  • From the library (estimated): what the agent read and wrote through the server, counted as text: five playbooks (about 25,000 tokens), nine licensed cards (about 61,000), the parts’ code read in and written out (about 215,000). About 0.3 million tokens.
  • From scratch (our guess): the nine parts are about 108,000 tokens of finished code, several of them GPU work (a physical sky, an FFT ocean, height fog). Agents usually get there in rounds (write, run, read the errors, fix), re-reading the code and the conversation each time; a session that ends in tested code commonly spends 15 to 40 times the size of the result. That gives about 1.5 to 4 million tokens, and 6 to 15 hours.
  • What it leaves out: the app’s own code (the scene, the forecast, the glue) costs the same either way. The saving is in the parts, and it grows with every part you’d otherwise write. Models, agents and prices vary; treat it as an order of magnitude.
Set it up

One line, no account.

Add the server and your agent can plan with the whole library. To install parts you own, add an access token from your account; it sees exactly what you own.

In a terminal, in your project:

claude mcp add --transport http feature-library https://featurelibrary.com/mcp

With your licence, to install the parts you own:

claude mcp add --transport http feature-library https://featurelibrary.com/mcp --header "Authorization: Bearer $FEATURE_STORE_TOKEN"

Then ask it for what you are building. It calls get_brief first and follows the library’s rules. Make the token on your account page and keep it in your environment as FEATURE_STORE_TOKEN.

Try a search

Ask the library yourself.

This box calls the same server and the same free tool your agent uses. It matches words, so describe what the part has to do, the way the library would: “rain and snow”, “date picker”, “sortable table”.

Or:
Your users’ device

Every part is measured on each. Pick the weakest you need to support: parts that fit it come first, and where WebGPU is missing, parts with a WebGL or CSS fallback stay in while the rest drop to the end.

How much of the frame it may take

A smooth frame has 16.7 ms for everything. Keep this low for something light beside the rest of your app; raise it for a centrepiece.

    And also

    A real build

    Every call, in order

    An agent built the storm watch from the library alone, through this server. See what it asked for, in what order, and what we learned watching it.

    How it was built
    Prices

    Plan free, pay per part

    Planning, kits, playbooks and every part’s pitfall titles cost nothing. Installing needs a licence for the part: from €9 at launch, in packs, or the whole library. Six starter parts are free.

    See pricing
    No agent

    Packages and downloads

    The same parts install with npm from your own feed, or download as files from your account. The catalogue is free to read as catalogue.json, and assistants can start from llms.txt.

    Browse the parts