New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Official agent skill

Complete Partial PR

by pydantic in pydantic/pydantic-ai

Evaluate and complete an issue or PR where the submitted patch fixes only a narrow symptom of the reported pain point.

OfficialMITAuto-check passedAI & LLM Engineering

Install Complete Partial PR

skills CLI
$ npx skills add pydantic/pydantic-ai --skill complete-partial-pr -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install pydantic/pydantic-ai complete-partial-pr --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/pydantic/pydantic-ai.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/complete-partial-pr .claude/skills/complete-partial-pr && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
complete-partial-pr
GitHub stars
20k
Token cost
~2.4k tokens
SKILL.md length
1,158 words
Files
1
Skills in repo
20
Repo updated
First seen
Licence
MIT

At a glance

Evaluate and complete an issue or PR where the submitted patch fixes only a narrow symptom of the reported pain point.

  • Works in 9 steps: Startup → Resolve The Work Item → Reconstruct The Pain Point → …
  • A contribution may miss adjacent integration surfaces
  • SKILL.md covers When To Use, Operating Principle, Delegation and Workflow, plus 1 more section
  • Calls git, gh and uv

What it does

Complete Partial PR is an agent skill from pydantic/pydantic-ai, published by the product's own GitHub organization. Evaluate and complete an issue or PR where the submitted patch fixes only a narrow symptom of the reported pain point. Use when a contribution may miss adjacent integration surfaces, provider/spec semantics, roundtrip behavior, tests, docs, or historical maintainer decisions.

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in AI & LLM Engineering. It works with Pydantic AI. The repository describes itself as: How Python does AI. Agents, realtime voice, image generation, embeddings. Every model, every interface, typed end to end. The licence is MIT.

When your agent uses it

  • A contribution may miss adjacent integration surfaces
  • Provider/spec semantics
  • Roundtrip behavior
  • Historical maintainer decisions

Example prompts

  • “/complete-partial-pr”

Requirements

  • Pre-approved tools (allowed-tools): Bash(git:*), Bash(gh:*), Bash(jq:*), Bash(rg:*), Bash(sed:*), Bash(ls:*), Bash(cat:*), Bash(mkdir:*), Bash(date:*), Bash(uv:*), Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Agent

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. Startup
  2. Resolve The Work Item
  3. Reconstruct The Pain Point
  4. Verify The Spec
  5. Map The Integration Surface
  6. Check History
  7. Decide The Correct Scope
  8. Implement Conservatively
  9. Communicate And Push

What it can do on your machine

Read from SKILL.md and the folder at commit f55bb8a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash(git:*)
    • Bash(gh:*)
    • Bash(jq:*)
    • Bash(rg:*)
    • Bash(sed:*)
    • Bash(ls:*)
    • Bash(cat:*)
    • Bash(mkdir:*)
    • Bash(date:*)
    • Bash(uv:*)

    …and 8 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh
    • uv

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, gh and uv, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Complete Partial PR loads about 2.4k tokens when it runs. Until then it costs about 74 tokens; SKILL.md has 1,158 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~74
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from pydantic/pydantic-ai at commit f55bb8a, republished under its MIT licence (© pydantic). 1,158 words, ~2,393 tokens.

Download SKILL.mdSave it as .claude/skills/complete-partial-pr/SKILL.md (or your agent's skills folder).
name
complete-partial-pr
description
Evaluate and complete an issue or PR where the submitted patch fixes only a narrow symptom of the reported pain point. Use when a contribution may miss adjacent integration surfaces, provider/spec semantics, roundtrip behavior, tests, docs, or historical maintainer decisions.
allowed-tools
Bash(git:*), Bash(gh:*), Bash(jq:*), Bash(rg:*), Bash(sed:*), Bash(ls:*), Bash(cat:*), Bash(mkdir:*), Bash(date:*), Bash(uv:*), Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Agent
user-invocable
true

Complete Partial PR

Use this when a PR or issue patch fixes a small visible failure but may not address the full integration contract. The goal is to turn a narrow contribution into a maintainable Pydantic AI change, or to explain precisely why it should stay narrow.

This is not limited to UI or provider integrations. Apply it to any patch that touches one variant of a broader surface: parse/dump, request/response, streaming/non-streaming, static/dynamic, sync/async, native/provider/local tools, metadata, state machines, durable execution, docs, or tests.

When To Use

  • A contributor's PR addresses the immediate error but not the rest of the user's workflow.
  • A fix accepts one shape of data but may not preserve roundtrip semantics.
  • A provider or external protocol has more states, fields, or variants than the PR covers.
  • The user asks "is this enough?", "what did the contributor miss?", "verify this against the spec", or "improve this branch".
  • A reviewer suspects the patch contradicts historical decisions or creates future integration debt.

Do not use this as a replacement for /review-branch when the task is only a general code review. If the PR has no local context yet, run /adopt-pr first.

Operating Principle

Separate three things before implementing:

  1. The contributor's exact patch.
  2. The underlying user pain point.
  3. The integration contract Pydantic AI should support.

Only (3) determines the final shape. The submitted patch is evidence, not the boundary.

Delegation

Use subagents for independent research and review lanes. Keep the critical path local: branch selection, final synthesis, implementation, and push decisions.

Good subagent lanes:

  • Spec researcher: read the linked issue/PR, provider docs, SDK types, protocol docs, and relevant project docs. Return source-backed facts only, with URLs or file paths.
  • Codepath mapper: map affected code and adjacent surfaces: loaders, dumpers, stream handlers, request builders, response parsers, tool/native-tool paths, model profiles, docs, and tests.
  • History researcher: inspect git blame, git log, previous PRs, review comments, and decision logs around the touched code. Return historical decisions with source links.
  • Test-shape reviewer: decide what coverage proves the full contract without bloating tests. Identify where parametrization, snapshots, VCR, or direct adapter tests are appropriate.

Give each subagent a narrow question, known PR/issue number, relevant file paths, and the exact output you need. Do not ask multiple subagents to answer the same question. Claims that answer the task need a source.

Workflow

1. Startup

Read the local context before scoping:

  • CLAUDE.md and CLAUDE.local.md
  • agent_docs/index.md
  • .claude/skills/branch-context/issue-brief.md and .claude/skills/branch-context/pr-decisions.md, if present
  • agent_docs/pydantic-ai-slim.md (Ownership section) and pydantic_ai_slim/pydantic_ai/native_tools/AGENTS.md for the affected feature group
  • pydantic_ai_slim/pydantic_ai/{profiles,providers,models}/AGENTS.md, pydantic_ai_slim/pydantic_ai/AGENTS.md, and the Design Rules section of agent_docs/pydantic-ai-slim.md for layer ownership
  • the root CLAUDE.md / AGENTS.md ethos ("channel your inner Samuel Colvin") and agent_docs/index.md for review tells

If the investigation spans multiple surfaces or subagents, create a short working note under local-notes/, for example local-notes/complete-partial-pr.md. Keep facts, sources, and open questions there. Do not put research prose in issue-brief.md.

2. Resolve The Work Item

Use gh for GitHub context.

bash
gh pr view <PR> --json number,title,url,state,body,author,headRepository,headRepositoryOwner,headRefName,maintainerCanModify,baseRefName,comments,reviews,closingIssuesReferences

Read linked issues, PR comments, review threads, and CI context. If the work item is an issue with no PR, inspect the linked branch or proposed patch if one exists.

For fork PRs, record:

  • headRepository.nameWithOwner
  • headRefName
  • maintainerCanModify
  • whether a plain git push targets the actual PR branch

Never force push. If updating a contributor PR and maintainerCanModify allows it, push to the contributor's PR branch. If not, create a separate branch and report the limitation.

3. Reconstruct The Pain Point

Write a short local working note, even if it only lives in the final report:

  • What user workflow failed?
  • Which exact symptom does the PR fix?
  • Which broader contract might users reasonably expect?
  • Which variants or states are implied by the same contract?
  • What would be a deliberate non-goal?

This note keeps the implementation from being scoped by the first test the contributor happened to write.

4. Verify The Spec

Find authoritative sources before changing code:

  • Provider docs, SDK types, protocol references, or API schemas.
  • Pydantic AI docs and public API contracts.
  • Existing tests and snapshots that encode current behavior.

For external technical specs, use primary sources. If the spec is versioned, note the version used by Pydantic AI and whether the PR targets the same version. Distinguish confirmed spec behavior from inference.

Show full SKILL.md (460 more words)Show less
5. Map The Integration Surface

Search for symmetric and adjacent code paths. Typical pairs and variants:

  • load / dump
  • parse / serialize
  • request / response
  • streaming / non-streaming
  • initial / intermediate / final states
  • success / error / denied / unavailable
  • static / dynamic
  • function tools / native tools / provider-executed tools
  • IDs, provider names, metadata, and roundtrip preservation
  • sync / async
  • public API / internal adapter / docs / examples / skills

Do not assume a one-line parser fix is sufficient until this map is complete.

6. Check History

Use local git history and GitHub history around the touched code:

bash
git blame -- <path>
git log --oneline -- <path>
gh pr list --search '<symbol-or-file> repo:pydantic/pydantic-ai' --state all --json number,title,url,state

Read previous PRs or comments that introduced the relevant behavior. Capture any decision that constrains the new change. If the new approach contradicts history, call that out explicitly before implementing.

7. Decide The Correct Scope

Classify missing work:

  • Required: needed for spec compliance, roundtrip correctness, backwards compatibility, or the reported user workflow.
  • Regression test: behavior that should remain deliberately unsupported or should not silently regress.
  • Nice to have: adjacent polish that is not required for this PR.
  • Out of scope: broader feature work that deserves a separate issue or design discussion.

Push back on expanding the PR only when the broader behavior is genuinely a separate product decision. Otherwise, complete the contract.

If choosing broader scope or explicitly deferring an adjacent surface, append a concise entry to .claude/skills/branch-context/pr-decisions.md with the source that justified the decision.

If the broader fix changes public API, provider semantics, durable behavior, or safety posture in a non-obvious way, ask a maintainer before coding or draft a PR comment/proposal instead of silently expanding the branch.

8. Implement Conservatively

Prefer small changes that fit existing abstractions. Preserve backwards compatibility and avoid new public API unless the full contract requires it.

For tests:

  • Cover the behavior at the same level users rely on it.
  • Prefer integration/adapter-level tests over clusters of helper tests.
  • Parametrize related variants and states to reduce bloat.
  • Use VCR only when the real provider interaction is the behavior under test. Local protocol conversion usually belongs in direct tests.
  • Include regression tests for deliberate non-support decisions.

Run targeted checks first, for example:

bash
uv run pytest tests/<target>.py::<test_name>
PYRIGHT_PYTHON_IGNORE_WARNINGS=1 uv run pyright <changed-file.py>

Escalate to broader checks only when the blast radius warrants it.

After code changes, run /review-branch unless the change is documentation-only or the user explicitly asks for a narrower pass.

9. Communicate And Push

Before pushing, verify the remote target:

bash
git remote -v
git branch -vv
git status --short --branch

If posting a GitHub comment, summarize:

  • What the original PR covered.
  • What additional integration surfaces were checked.
  • What improvements were added.
  • Which spec and historical sources were used.
  • Which tests were run.

If the work changes durable project knowledge, update the relevant docs, branch-context, or skill files.

Output Checklist

End with a concise report containing:

  • Work item and branch updated.
  • Spec sources checked.
  • Historical decisions checked.
  • Integration surfaces covered.
  • Tests added or changed.
  • Commands run.
  • Remaining non-goals or follow-up issues.

© pydantic, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/complete-partial-pr of pydantic/pydantic-ai.

Open the folder on GitHubat commit f55bb8a

Compare with similar skills

Complete Partial PR next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Complete Partial PR compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Complete Partial PR this skillpydantic/pydantic-ai20k—~2.4kAutomated safety check: PassMIT
Langfuse Integration Pagelangfuse/langfuse-docs246—~3.7kAutomated safety check: PassMIT
Pydanticai Docsaiskillstore/marketplace4301 repos~1.2kAutomated safety check: PassNone
Building Pydantic AI Agentsdocling-project/docling69k—~2.8kAutomated safety check: PassMIT
Failproof AI SDK IntegrationFailproofAI/failproofai5.3k—~6kAutomated safety check: PassCustom licence
Bootstrapping Agentairbytehq/airbyte-agent-sdk135—~1.7kAutomated safety check: NotesCustom licence

Similar skills

  • Langfuse Integration Page

    langfuse/langfuse-docs

    Create a new Langfuse integration page in the langfuse-docs repo.

    246 GitHub stars~3.7k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • Pydanticai Docs

    aiskillstore/marketplace

    A skill your agent uses for requests related to Pydantic AI framework - building agents, tools, dependencies, structured outputs, and model integrations.

    430 GitHub starsUsed in 1 repo~1.2k tokens
    AI & LLM EngineeringAuto-check passed

  • Building Pydantic AI Agents

    docling-project/docling

    Patterns and tested examples for building agents with Pydantic AI: tools, capabilities, structured output, dependency injection, hooks, YAML specs, streaming and testing.

    69k GitHub stars~2.8k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • Failproof AI SDK Integration

    FailproofAI/failproofai

    Helps instrument a custom Python or TypeScript agent to record events for Failproof AI, verify what gets written, and run an evaluator worker that scores the runs.

    5.3k GitHub stars~6k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

  • Bootstrapping Agent

    airbytehq/airbyte-agent-sdk

    Official

    Wires up an Airbyte connector for use in a PydanticAI, Claude SDK, or other agent.

    135 GitHub stars~1.7k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check: notes

  • Building Pydantic AI Agents

    pydantic/skills

    Official

    Build AI agents with Pydantic AI — tools, capabilities (including on-demand loading), structured output, streaming, testing, and multi-agent patterns.

    140 GitHub stars~5.4k tokensUpdated 6 days ago
    AI & LLM EngineeringAuto-check passed

More from pydantic/pydantic-ai

All 20 skills in this repo

  • Pydantic AI Harness

    pydantic/pydantic-ai

    Official

    Adds optional capabilities to Pydantic AI agents from pydantic-ai-harness, led by Code Mode, which runs many tool calls as one sandboxed Python script.

    20k GitHub stars~4.9k tokensUpdated today
    Auto-check passed

  • Building Pydantic AI Agents

    pydantic/pydantic-ai

    Official

    Build AI agents with Pydantic AI — tools, capabilities (including on-demand loading), workspaces, structured output, streaming, testing, and multi-agent patterns.

    20k GitHub stars~8k tokensUpdated today
    Auto-check passed

  • Testing Skill

    pydantic/pydantic-ai

    Official

    Record, rewrite, and debug VCR cassettes for HTTP recordings.

    20k GitHub stars~839 tokensUpdated today
    Auto-check: notes

  • Migrating Agno To Pydantic AI

    pydantic/pydantic-ai

    Official

    Migrate Python Agno applications to Pydantic AI and, only when needed, Pydantic AI Harness.

    20k GitHub stars~1.8k tokensUpdated today
    Auto-check passed

  • Migrating Claude Agent SDK To Pydantic AI

    pydantic/pydantic-ai

    Official

    Migrate Python applications from the Claude Agent SDK to Pydantic AI and, only when needed, Pydantic AI Harness.

    20k GitHub stars~1.6k tokensUpdated today
    Auto-check passed

  • Deep Agents to Pydantic AI Migration

    pydantic/pydantic-ai

    Official

    Migrates Python LangChain Deep Agents applications to Pydantic AI and Pydantic AI Harness while preserving the application's observed behavior.

    20k GitHub stars~1.7k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Complete Partial PR

What does Complete Partial PR do?

Evaluate and complete an issue or PR where the submitted patch fixes only a narrow symptom of the reported pain point. Complete Partial PR is an agent skill from pydantic/pydantic-ai, published by the product's own GitHub organization. Evaluate and complete an issue or PR where the submitted patch fixes only a narrow symptom of the reported pain point.

When should I use Complete Partial PR?

Complete Partial PR fits situations like: A contribution may miss adjacent integration surfaces; provider/spec semantics; roundtrip behavior; historical maintainer decisions.

How do I install Complete Partial PR in Claude Code?

Run `npx skills add pydantic/pydantic-ai --skill complete-partial-pr -a claude-code`. Or copy the skill folder (.agents/skills/complete-partial-pr in pydantic/pydantic-ai) into .claude/skills/complete-partial-pr in your project. Claude Code loads it when a task matches its description.

How do I install Complete Partial PR in Codex?

Run `npx skills add pydantic/pydantic-ai --skill complete-partial-pr -a codex`. Or copy the skill folder (.agents/skills/complete-partial-pr in pydantic/pydantic-ai) into .agents/skills/complete-partial-pr in your project. Codex loads it when a task matches its description.

Can I use Complete Partial PR in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add pydantic/pydantic-ai --skill complete-partial-pr -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/complete-partial-pr, .gemini/skills/complete-partial-pr, .github/skills/complete-partial-pr and .opencode/skills/complete-partial-pr in your project.

What does Complete Partial PR need to run?

Going by SKILL.md and its folder, Complete Partial PR needs the command-line tools its instructions call (git, gh and uv). Its frontmatter pre-approves these tools: Bash(git:*), Bash(gh:*), Bash(jq:*), Bash(rg:*), Bash(sed:*), Bash(ls:*), Bash(cat:*), Bash(mkdir:*), Bash(date:*), Bash(uv:*), Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion, Agent.

Does Complete Partial PR access the network?

SKILL.md contains no URLs. Its commands use git, gh and uv, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Complete Partial PR safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Complete Partial PR use?

Complete Partial PR is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Complete Partial PR use?

About 2.4k tokens (SKILL.md is roughly 9.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Complete Partial PR?

Skills that share tags, products or a category with Complete Partial PR: Langfuse Integration Page (langfuse/langfuse-docs, 246 stars), Pydanticai Docs (aiskillstore/marketplace, 430 stars), Building Pydantic AI Agents (docling-project/docling, 69k stars) and Failproof AI SDK Integration (FailproofAI/failproofai, 5.3k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Complete Partial PR?

pydantic (a GitHub organization, an official publisher) maintains it in pydantic/pydantic-ai, which has 20,476 GitHub stars. The repository holds 20 skills in this directory. The repository was last updated on October 8, 2026.

Source: pydantic/pydantic-ai on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.