explainx / blog
Y Combinator's Paxel scans Claude Code, Codex CLI, and Cursor transcripts to create builder reports with archetypes, prompt stats, and work patterns. One command generates a shareable token for YC Startup School applications.
Jun 7, 2026
Discover 185+ AI coding plugins from OpenAI and Anthropic on explainx.ai.
Jun 7, 2026
OpenAI's official plugins repository features curated Codex plugin examples for Figma design workflows, Notion integration, iOS/macOS app development, web deployment, and MCP server connections.
Jun 5, 2026
Matt Pocock's full AI coding workshop covers practical engineering workflows: smart zone vs dumb zone, grill-me alignment, PRD-to-vertical-slices, TDD with AI, AFK agents, Sand Castle parallelizati...
On June 6, 2026, Y Combinator launched Paxel—a free command-line tool that analyzes your local AI coding sessions from Claude Code, Codex CLI, and Cursor to generate comprehensive "builder reports" featuring coding archetypes, prompt statistics, and work pattern analysis. The tool promises to identify exceptional builders and boost YC Startup School applications with shareable profile tokens.
But within hours of launch, a controversy erupted. YC claimed "your code never leaves your machine," yet security researchers discovered the tool uploads prompt excerpts, git metadata, file paths, and tool usage patterns to YC servers. The International Cyber Digest published a detailed breakdown showing exactly what data Paxel extracts and transmits, raising critical privacy questions for developers.
Despite the privacy debate, founders are praising Paxel's ability to surface hidden talent. YC partner Rohit Mittal called it "the type of innovation needed at the early stage to get the right founders through the door," comparing it to YC's pioneering 10-minute interview format. The tool runs one Docker command, analyzes 15-30 minutes of transcripts, and produces a builder profile that can differentiate applicants in an increasingly competitive startup landscape.
This guide explores Paxel's architecture, the builder archetypes it identifies, the privacy implications of its data collection, and what it means for the future of technical recruiting and YC applications.
Y Combinator receives 50,000+ applications per batch for ~500 interview slots. Founders submit applications with:
The challenge: How do you identify technical excellence from text responses?
Traditional signals are noisy:
YC needed a behavioral signal—something that reveals how founders actually build, think, and solve problems in their natural workflow.
Paxel analyzes local AI coding transcripts to extract signals YC believes correlate with exceptional builders:
What it scans:
.jsonl files from ~/.claude/projects/)What it generates:
How it works:
docker run -v ~/.claude:/claude -v ~/.cursor:/cursor ycombinator/paxel (simplified example)pxl_abc123xyzYC reviewers see your builder profile alongside your written application, giving them insight into your technical workflow, problem-solving patterns, and coding maturity.
Paxel classifies builders into archetypes based on coding patterns. While YC hasn't disclosed the full taxonomy, early users report seeing:
Characteristics:
Prompt example:
"Before implementing auth, let's explore the existing patterns. Search the codebase for session management, token storage, and middleware patterns. Compare approaches in user service vs admin service. Then propose an architecture that unifies them."
Work pattern:
YC signal:
Characteristics:
Prompt example:
"Add a login button to the navbar. Make it blue. Add onClick handler."
Work pattern:
YC signal:
Characteristics:
Prompt example:
"Getting TypeError on line 42. Read the component file. Check prop types. Run the test. Why is userId undefined?"
Work pattern:
YC signal:
Characteristics:
Prompt example:
"Should we use REST or GraphQL for the API? What's our expected query complexity? How important is real-time updates?"
Work pattern:
YC signal:
Characteristics:
Prompt example:
"Build a user dashboard with auth, data visualization, and export functionality. Use our existing design system. Write tests. Deploy to staging."
Work pattern:
YC signal:
YC's launch announcement stated:
"It runs locally inside Docker, and your code never leaves your machine."
Security researcher International Cyber Digest (@IntCyberDigest) published a thread hours later revealing:
"A new YC tool that analyzes your AI coding habits promises 'your code never leaves your machine.' By their own code, it does."
What actually leaves your system:
From Read tool outputs and Edit tool payloads:
{
"tool": "Read",
"file_path": "/src/auth/login.tsx",
"content": "export const LoginForm = () => { ... }" // Full file content
}
Paxel extracts:
YC's defense: Only sends "anonymized excerpts" for pattern analysis, not full files.
Privacy concern: Excerpts can contain API keys, internal URLs, proprietary algorithms, or sensitive business logic.
From .git/ directory scans:
{
"commits": [
{
"hash": "abc123",
"message": "Add Stripe payment integration",
"timestamp": "2026-06-05T14:23:00Z",
"files_changed": ["src/payments/stripe.ts", "src/api/checkout.ts"]
}
],
"branches": ["main", "feature/crypto-payments", "experiment/ai-pricing"]
}
What this reveals:
Full prompt text and metadata:
{
"prompt": "Build a recommendation engine using collaborative filtering...",
"length": 247,
"tools_invoked": ["Bash", "Edit", "Write"],
"session_duration": 3600,
"time_of_day": "23:15"
}
What this reveals:
Directory paths from Glob/Grep tool usage:
/Users/alice/code/stealth-startup/
/src/ml/recommendation_engine.py
/src/api/crypto_trading.ts
/tests/backtesting/
What this reveals:
| Data Type | Sensitivity | Uploaded to YC? |
|---|---|---|
| Full source code | 🔴 Critical | ❌ No (confirmed) |
| Code excerpts | 🟡 Medium | ✅ Yes |
| Git commit messages | 🟡 Medium | ✅ Yes |
| File paths | 🟡 Medium | ✅ Yes |
| Prompts (full text) | 🟢 Low | ✅ Yes |
| Tool usage stats | 🟢 Low | ✅ Yes |
| Timestamps | 🟢 Low | ✅ Yes |
Verdict: Paxel collects more data than YC's marketing suggests, but less than a full codebase scrape.
Paxel runs in a Docker container to sandbox file access:
docker run -v ~/.claude:/claude \
-v ~/.cursor:/cursor \
-v ~/.codex:/codex \
-v $(pwd):/workspace \
ycombinator/paxel
Mounted volumes:
~/.claude/projects/ - Claude Code JSONL transcripts~/.cursor/ - Cursor chat history~/.codex/ - Codex CLI session logs$(pwd) - Current git repository (for commit metadata)Paxel iterates through .jsonl transcript files:
import json
def parse_claude_transcript(path):
sessions = []
with open(path) as f:
for line in f:
msg = json.loads(line)
if msg["type"] == "tool_use":
sessions.append({
"tool": msg["name"],
"input": msg["input"],
"timestamp": msg["timestamp"]
})
return sessions
Extracted features:
Paxel computes behavioral metrics:
1. Planning Ratio
planning_ratio = (
count(Glob, Grep, Read) /
count(Edit, Write, Bash)
)
High ratio → Architect archetype Low ratio → Sprinter archetype
2. Iteration Depth
iteration_depth = avg(
edits_per_file_before_commit
)
High depth → Debugger archetype Low depth → Sprinter archetype
3. Autonomy Score
autonomy_score = (
1 - (count(AskUserQuestion) / total_prompts)
)
High score → Autonomous Agent archetype Low score → Collaborator archetype
4. Temporal Patterns
work_hours = histogram(
hour_of_day(tool_call.timestamp)
)
Reveals work habits, timezone, focus periods
Paxel likely uses a decision tree or clustering algorithm:
from sklearn.tree import DecisionTreeClassifier
features = [
planning_ratio,
iteration_depth,
autonomy_score,
avg_prompt_length,
tool_diversity
]
archetype = classifier.predict(features)
# Returns: "Architect" | "Sprinter" | "Debugger" | ...
Paxel generates a visual report (HTML + charts) and a shareable token:
token = generate_token(user_id, archetype, stats)
# Returns: "pxl_abc123xyz"
report = {
"archetype": "Architect",
"stats": {
"total_sessions": 247,
"total_prompts": 1893,
"avg_prompt_length": 156,
"planning_ratio": 2.4,
"code_velocity": 487 # lines/hour
},
"chart_data": { ... }
}
Token is stored on YC servers:
POST https://paxel.ycombinator.com/api/tokens
{
"token": "pxl_abc123xyz",
"archetype": "Architect",
"stats": { ... },
"excerpts": [ ... ] # Code snippets, prompts
}
# Install Docker (if not already installed)
brew install docker
# Run Paxel
docker run -v ~/.claude:/claude \
-v ~/.cursor:/cursor \
-v $(pwd):/workspace \
ycombinator/paxel
Analysis time: 15-30 minutes (depends on transcript size)
Example output:
╔══════════════════════════════════════════╗
║ PAXEL BUILDER REPORT v1.0 ║
╚══════════════════════════════════════════╝
🎯 Archetype: THE ARCHITECT
📊 Statistics (Last 90 Days):
• Total Sessions: 247
• Total Prompts: 1,893
• Avg Prompt Length: 156 chars
• Planning Ratio: 2.4
• Code Velocity: 487 lines/hour
• Autonomy Score: 0.82
🔧 Top Tools:
1. Read (34%)
2. Grep (18%)
3. Edit (16%)
4. Task/Explore (12%)
5. Bash (11%)
⏰ Work Patterns:
Peak Hours: 22:00-02:00 UTC
Avg Session: 2.3 hours
Preferred Days: Weekends
🏆 Standout Traits:
• High design-before-implementation ratio
• Low code churn (rewrites rare)
• Strong codebase exploration habits
• Systems thinking evident in prompts
🔗 Shareable Token:
pxl_arch_2x9k3m5p7q
Paste this token in your YC application.
pxl_arch_2x9k3m5p7qImpact on acceptance rate:
YC hasn't disclosed data, but early users report:
Create a script to strip sensitive data:
import json
import re
def sanitize_transcript(input_path, output_path):
sensitive_patterns = [
r'sk-[A-Za-z0-9]{48}', # OpenAI keys
r'Bearer [A-Za-z0-9_-]+', # Auth tokens
r'https?://[^\s]+\.internal', # Internal URLs
r'password\s*=\s*["\'].*?["\']' # Passwords
]
with open(input_path) as f_in, open(output_path, 'w') as f_out:
for line in f_in:
msg = json.loads(line)
# Sanitize tool inputs
if 'input' in msg:
content = json.dumps(msg['input'])
for pattern in sensitive_patterns:
content = re.sub(pattern, '[REDACTED]', content)
msg['input'] = json.loads(content)
f_out.write(json.dumps(msg) + '\n')
Run Paxel on sanitized transcripts:
python sanitize.py ~/.claude/project.jsonl /tmp/sanitized.jsonl
docker run -v /tmp:/claude ycombinator/paxel
Generate the report locally without uploading:
docker run -e PAXEL_OFFLINE=true \
-v ~/.claude:/claude \
ycombinator/paxel
Tradeoff: No shareable token for YC application.
Generate synthetic transcripts to test Paxel without exposing real data:
import json
from datetime import datetime, timedelta
fake_transcript = []
for i in range(100):
fake_transcript.append({
"type": "tool_use",
"name": "Read",
"input": {"file_path": f"/src/component_{i}.tsx"},
"timestamp": (datetime.now() - timedelta(hours=i)).isoformat()
})
with open('/tmp/fake.jsonl', 'w') as f:
for msg in fake_transcript:
f.write(json.dumps(msg) + '\n')
Use case: Understand Paxel's analysis without risking privacy.
Benefits:
Risks:
Recommendation:
Use Paxel if:
Skip Paxel if:
Why Paxel makes sense:
Potential issues:
Future evolution:
Paxel represents a new category of technical recruiting:
Traditional hiring:
AI-native hiring:
Potential applications beyond YC:
Ethical concerns:
Rohit Mittal (YC Partner):
"This is an amazing idea by YC. This is the type of innovation needed at the early stage to get the right founders through the door. YC pioneered the 10 min interview and is still the only one to do it. Now, with new innovations like these in attracting the right founders, they continue to lead."
0xPuff (VC/Founder):
"Paxel is genius. Finally a way to objectively measure technical ability beyond 'I worked at Google.' Watching my coding sessions analyzed in real-time is wild—turns out I'm a 'Debugger' archetype lol."
International Cyber Digest (Security Researcher):
"❗️ A new YC tool that analyzes your AI coding habits promises 'your code never leaves your machine.' By their own code, it does. What leaves your system: Your code, in excerpts. Tool-output snippets are literal source: a Read returns file contents, an Edit carries what you changed. Git metadata. Commit messages, branch names, file paths—your entire product roadmap."
Privacy advocates:
"This is surveillance theater. YC is building the world's largest database of founder coding patterns. Today it's 'optional' for applications. Tomorrow it's required. Next year they sell insights to VCs."
If you want builder profiling without YC's data collection:
Free tool that tracks coding time across editors:
Similar to WakaTime, focused on VS Code:
Build your own Paxel using Claude Code transcripts:
import json
def analyze_my_transcripts(path):
tools = {}
prompts = []
with open(path) as f:
for line in f:
msg = json.loads(line)
if msg["type"] == "tool_use":
tools[msg["name"]] = tools.get(msg["name"], 0) + 1
elif msg["type"] == "user_message":
prompts.append(len(msg["content"]))
print(f"Tool usage: {tools}")
print(f"Avg prompt length: {sum(prompts)/len(prompts)}")
analyze_my_transcripts("~/.claude/projects/my-project.jsonl")
Benefit: Full control, zero privacy risk
Paxel represents a fundamental shift in how technical ability is measured. Rather than relying on proxies—resumes, interviews, coding challenges—YC is analyzing actual building behavior in developers' natural workflows.
The tool has clear benefits:
But it also raises critical questions:
For founders applying to YC, Paxel is an optional but powerful signal. If your AI coding habits are strong and your codebase doesn't contain sensitive IP, using Paxel could differentiate your application. If you're working on confidential projects or uncomfortable with behavioral profiling, skip it.
For the broader industry, Paxel previews a future where workflow data becomes the new resume. GitHub, GitLab, and developer tool companies are likely watching closely. Behavioral coding analysis could become the default hiring signal within 2-3 years.
The question is not whether this future arrives, but whether it respects developer privacy and autonomy when it does.
Official:
docker pull ycombinator/paxelPrivacy analysis:
Alternatives: