How to use the Recsys Pipeline Architect agent skill

What the skill makes the agent do

The skill gives the agent a fixed six-stage pattern for building a pipeline: Source, Hydrator, Filter, Scorer, Selector, and SideEffect. The pattern is popularized by xAI's open-sourced For You algorithm, and the skill applies it to any problem of the form 'the top K items for a (user, context)'.

The agent walks you through the stages in order: it gathers candidates, enriches them with the data needed for filtering and scoring, removes ineligible items, scores the rest, selects the top K, and then runs background tasks such as caching or logging. It can then generate starter code in your stack, and it raises design decisions for you to make.

• Source: fetch candidates from one or more origins, in parallel where possible
• Hydrator: add metadata that filters and scorers need
• Filter: drop blocked, expired, duplicate or otherwise ineligible items
• Scorer: assign one or more scores to each surviving item
• Selector: sort by final score and return the top K
• SideEffect: cache, log, emit events or update served history without blocking the response

How to install the skill

Download the skill ZIP from this page. Unzip it into your personal skills folder, ~/.claude/skills/, or into a project's .claude/skills/ folder if you want the skill available only inside that project.

If you use the Claude apps instead, open Settings, go to Capabilities, and upload the skill under Skills. The skill package contains a single file, SKILL.md, so there is nothing else to set up.

• Personal install: ~/.claude/skills/
• Project install: the .claude/skills/ folder inside your project
• Claude apps: Settings → Capabilities → Skills, then upload

How to trigger the skill with natural requests

You do not need a special command. Describe a system that picks the top K items for a user or context, and the agent should recognize the task. Naming the situation helps: say what is being ranked, what the input context is, and what language or runtime you use.

Good triggers include requests about feeds, search ranking, RAG rerankers, task prioritizers, notification triage, and ad selection. If the agent does not seem to use the skill, restate the request with the words 'recommendation pipeline' or 'ranking pipeline' and mention the six stages.

• 'Design a ranking pipeline for a personalized article feed in our Strapi CMS.'
• 'I have 50 chunks from my vector database. Add a reranker stage and return the top 5.'
• 'Help me build a daily digest that picks the top 10 notifications from the last 24 hours.'
• 'Plan a task prioritizer that suggests what a user should work on next.'

What the agent asks you and what it produces

The skill's workflow starts by clarifying the use case, asking up to three questions only if key details are missing: the items being ranked, the input context, and the language or runtime. It then works through candidate sources, the hydrations each filter and scorer needs, the filter list (cheap before expensive, universal before user-specific), the scorer chain, the selector, and the side effects.

The end result is a design and a scaffold in your stack. The skill's own rules require the scaffold to be runnable code rather than pseudocode, and to keep side effects non-blocking.

• Clarify the use case (one round of questions)
• Identify candidate sources, often in-network and out-of-network, or a single source
• List required hydrations
• List filters in order
• Design the scorer chain: primary model or heuristic, combiner, diversity, business rules
• Selector, then side effects

Key design choices the agent will raise

The skill is built to surface product decisions rather than make them silently. Three choices come up most often and each one changes how your system behaves over time.

Single score or multi-action prediction: a single relevance score requires retraining to change behavior, while multi-action prediction combines weighted action probabilities at serving time so you can tune weights without retraining. The skill recommends multi-action when you expect to tune often.

Isolated or joint scoring: isolated scoring is deterministic and cacheable, and the skill defaults to it. Joint scoring is more expressive but non-deterministic across batches.

Online or offline: request-time pipelines run on each request with a latency budget the skill cites as 100 to 300 milliseconds; pre-computed batch pipelines are faster to serve but less fresh. A hybrid, with retrieval offline and ranking online, is also possible.

Safety, requirements and limits

The skill's listing states that it requires nothing beyond itself, does not run scripts, and does not use the network. The package is a single SKILL.md file of instructions. It does not install libraries or call services on its own.

The code the agent writes is yours to review and run. The skill itself does not benchmark your system, and it instructs the agent not to invent performance numbers. Answers about speed depend on your workload and should be measured by you. Upstream reference material and example projects exist in a separate repository, which is not part of this single-file package.

• Requirements: none listed
• Runs scripts: no
• Uses network: no
• Licence: MIT

Tips for better results

Give concrete numbers and constraints early, such as the size of your catalogue, how many results you need, and how fresh the data must be. These determine the source and selector choices.

Ask the agent to explain each trade-off before it commits to one. Treat the generated scaffold as a starting point: add your own tests and tune the weights against real behavior.

Use the skill for ranking problems where personalization matters. For plain sorting or filtering, the six-stage structure adds more machinery than you need.

• State scale, latency needs and data freshness up front
• Ask for the trade-offs, not just the code
• Write tests for each stage and check that filters run before scorers