sharing-pr-agent-artifacts

Uploads agent-generated artifacts (specs, plans, learnings) to the streamlit.wiki for sharing via PR comments. Use when you have agent artifacts to share with reviewers.

44,152 stars

Best use case

sharing-pr-agent-artifacts is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Uploads agent-generated artifacts (specs, plans, learnings) to the streamlit.wiki for sharing via PR comments. Use when you have agent artifacts to share with reviewers.

Teams using sharing-pr-agent-artifacts should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/sharing-pr-agent-artifacts/SKILL.md --create-dirs "https://raw.githubusercontent.com/streamlit/streamlit/main/.claude/skills/sharing-pr-agent-artifacts/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/sharing-pr-agent-artifacts/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How sharing-pr-agent-artifacts Compares

Feature / Agentsharing-pr-agent-artifactsStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Uploads agent-generated artifacts (specs, plans, learnings) to the streamlit.wiki for sharing via PR comments. Use when you have agent artifacts to share with reviewers.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# Sharing PR agent artifacts

Uploads intermediate files (implementation plans, specs, learnings, explorations, architecture diagrams) to [streamlit.wiki](https://github.com/streamlit/streamlit.wiki.git) so they can be linked in PR descriptions and comments. Use this for agent-generated artifacts that are useful for reviewers but don't belong in the main repo.

**Important:** The wiki repo uses `master` as its default branch. Always push to `master`, never create other branches.

**Public URL pattern:**

```
https://issues.streamlit.app/agent_wiki_explorer?file=<relative-path>
```

Example: `https://issues.streamlit.app/agent_wiki_explorer?file=pull-requests/12345/implementation-plan.md`

## Prerequisites

- A PR must exist for the current branch

## Workflow

### 1. Get PR number

```bash
gh pr view --json number --jq '.number'
```

If no PR exists, stop and inform the user.

### 2. Set up wiki repo

Check if the wiki is already cloned:

```bash
if [ -d "agent-wiki/.git" ]; then
  # Use subshell to avoid directory navigation issues if pull fails
  (cd agent-wiki && git checkout master && git pull origin master)
else
  git clone https://github.com/streamlit/streamlit.wiki.git agent-wiki
fi
```

### 3. Create PR directory

```bash
mkdir -p agent-wiki/pull-requests/<pr-number>
```

### 4. Discover and copy files

**Common locations** (check these first):

- `work-tmp/` — temporary working files, drafts, exploration notes
- `specs/` — untracked product/tech specs created for this PR

**What to include:**

- Specs, plans, design docs (`.md`)
- Implementation notes and decisions
- Architecture diagrams (`.png`, `.svg`)
- Research findings and explorations

**Always exclude:**

> **Warning:** The wiki is a **public repo**. Never upload confidential information, internal sensitive discussions, or anything that shouldn't be publicly visible. Since Streamlit is open-source, almost all tech and product related planning documents are fine to share publicly.

- Files already tracked in the main repo (use `git ls-files` to check)
- Credentials, secrets, tokens, API keys (`.env`, `*credentials*`, `*secret*`, `*token*`, `*api_key*`)
- Confidential or internal-only information
- Test-related artifacts
- Debug logs and temporary output
- Build artifacts
- Large binary files (>10MB)
- IDE/editor files
- Files unrelated to the current PR

Copy selected files:

```bash
cp <file> agent-wiki/pull-requests/<pr-number>/
```

### 5. Commit and push

```bash
# Use subshell to avoid directory navigation issues
(
  cd agent-wiki
  git checkout master
  git add pull-requests/
  git commit -m "Add artifacts for PR #<pr-number>"
  git pull --rebase origin master
  git push origin master
)
```

If push fails due to conflicts:

1. Run `git pull --rebase origin master`
2. Resolve conflicts manually
3. Run `git rebase --continue`
4. Push again

Never use `--force`.

### 6. Comment on PR

If new files were added, post a summary comment to the PR:

```bash
gh pr comment <pr-number> --body "$(cat <<'EOF'
### Added Agent Docs

- [implementation-plan.md](https://issues.streamlit.app/agent_wiki_explorer?file=pull-requests/<pr-number>/implementation-plan.md): Main technical implementation plan
- [exploration.md](https://issues.streamlit.app/agent_wiki_explorer?file=pull-requests/<pr-number>/exploration.md): Initial research and design exploration
EOF
)"
```

Include only top-level documents relevant to reviewers. Assets embedded in those documents (e.g., images) don't need separate entries.

## Notes

- The `agent-wiki/` directory is gitignored and persists across sessions
- Always push to `master` — never create feature branches or use `--force`
- This is a **public repo** — never push sensitive information
- Only upload files directly relevant to the current PR

Related Skills

writing-spec

44152
from streamlit/streamlit

Writes product and tech specs for new Streamlit features. Use when designing new API commands, widgets, or significant changes that need team review before implementation.

updating-internal-docs

44152
from streamlit/streamlit

Review internal documentation (*.md files) against the current codebase state and propose updates for outdated or incorrect information.

understanding-streamlit-architecture

44152
from streamlit/streamlit

Explains Streamlit's internal architecture including backend runtime, frontend rendering, and WebSocket communication. Use when debugging cross-layer issues, understanding how features work end-to-end, planning architectural changes, or onboarding to the codebase. Covers ForwardMsg/BackMsg protocol, script rerun model, element tree, widget state management, and more.

implementing-feature

44152
from streamlit/streamlit

Implement a feature from a product/tech spec, URL, or GitHub issue. Reads the spec, implements the feature following Streamlit patterns, and creates a merge-ready PR. Use when given a spec folder path, document URL, or issue link to implement.

generating-changelog

44152
from streamlit/streamlit

Generates polished website release notes between two git tags for docs.streamlit.io. Use when preparing a new Streamlit release or reviewing changes between versions.

web-artifacts-builder

31392
from sickn33/antigravity-awesome-skills

To build powerful frontend claude.ai artifacts, follow these steps:

performing-threat-intelligence-sharing-with-misp

4032
from mukul975/Anthropic-Cybersecurity-Skills

Use PyMISP to create, enrich, and share threat intelligence events on a MISP platform, including IOC management, feed integration, STIX export, and community sharing workflows.

investigating-ransomware-attack-artifacts

4032
from mukul975/Anthropic-Cybersecurity-Skills

Identify, collect, and analyze ransomware attack artifacts to determine the variant, initial access vector, encryption scope, and recovery options.

implementing-security-information-sharing-with-stix2

4032
from mukul975/Anthropic-Cybersecurity-Skills

Create, validate, and share STIX 2.1 threat intelligence objects using the stix2 Python library. Covers indicators, malware, campaigns, relationships, bundles, and TAXII 2.1 publishing.

implementing-code-signing-for-artifacts

4032
from mukul975/Anthropic-Cybersecurity-Skills

This skill covers implementing code signing for build artifacts to ensure integrity and authenticity throughout the software supply chain. It addresses signing binaries, packages, and containers using GPG, Sigstore, and platform-specific signing tools, establishing trust chains, and verifying signatures in deployment pipelines.

extracting-windows-event-logs-artifacts

4032
from mukul975/Anthropic-Cybersecurity-Skills

Extract, parse, and analyze Windows Event Logs (EVTX) using Chainsaw, Hayabusa, and EvtxECmd to detect lateral movement, persistence, and privilege escalation.

extracting-memory-artifacts-with-rekall

4032
from mukul975/Anthropic-Cybersecurity-Skills

Uses Rekall memory forensics framework to analyze memory dumps for process hollowing, injected code via VAD anomalies, hidden processes, and rootkit detection. Applies plugins like pslist, psscan, vadinfo, malfind, and dlllist to extract forensic artifacts from Windows memory images. Use during incident response memory analysis.