Claude Skills by TravisLeeeeee

1. **Auto-Labeling** - Classify issues by type: bug, feature, enhancement, question, documentation - Add component labels based on file paths and keywords mentioned - Apply platform labels (iOS, Android, web, API, CLI) - Tag with affected version when mentioned - Add "good-first-issue" to well-scoped, low-complexity items

- Check naming conventions (variables, functions, classes) - Identify dead code, unused imports, unreachable branches - Flag functions exceeding 50 lines or cyclomatic complexity > 10 - Detect code duplication across changed files - Verify error handling covers edge cases - Check for proper typing and null safety

1. **Summary** — Overall assessment 2. **Blockers** — Must fix before merge 3. **Suggestions** — Should fix, not blocking 4. **Nitpicks** — Minor improvements 5. **Questions** — Things needing clarification

- Create comprehensive test plans for features, APIs, and user flows - Write end-to-end test cases with preconditions, steps, and expected results - Identify edge cases, boundary conditions, and negative test scenarios - Draft detailed bug reports with reproduction steps and severity ratings - Design regression test suites for critical paths

set -euo pipefail DIR="${1:-.}" DRY_RUN="${2:-}" DATE_PREFIX=$(date +%Y-%m-%d) COUNT=0 if [[ ! -d "$DIR" ]]; then echo "Error: Directory '$DIR' not found" >&2 exit 1 fi for file in "$DIR"/*.jpeg; do [[ -e "$file" ]] || { echo "No .jpeg files found in $DIR"; exit 0; } base=$(basename "$file" .jpeg) new_name="${DIR}/${DATE_PREFIX}_${base}.jpg" if [[ "$DRY_RUN" == "--dry-run" ]]; then echo "[DRY RUN] $file -> $new_name" else mv "$file" "$new_name" echo "Renamed: $file -> $new_name" fi ((COUNT++)...

Design software architectures that balance competing concerns:

service: payment-api slos: - name: Availability description: Successful responses to valid requests sli: count(status < 500) / count(total) target: 99.95% window: 30d burn_rate_alerts: - severity: critical short_window: 5m long_window: 1h factor: 14.4 - severity: warning short_window: 30m long_window: 6h factor: 6 - name: Latency description: Request duration at p99 sli: count(duration < 300ms) / count(total) target: 99% window: 30d ```

- Match incoming invoices to purchase orders and receiving documents (3-way match) - Route invoices for approval based on amount thresholds and department rules - Schedule payments to optimize cash flow while capturing early payment discounts - Track payment status and aging for all outstanding invoices - Maintain vendor records and flag discrepancies or duplicate invoices

- Monitor top traders on Polymarket, Kalshi, Binance, and other exchanges for new positions - Analyze trader performance history: win rate, average return, max drawdown, risk profile - Execute copy trades adjusted for the user's portfolio size and risk tolerance - Track open positions with real-time P&L and automated stop-loss management - Generate daily portfolio reports with attribution per copied trader

- Categorize incoming expenses into logical groups (food, transport, software, etc.) - Track spending against monthly budgets and alert when thresholds are approached - Generate weekly and monthly spending summaries with trend comparisons - Identify recurring charges and subscription costs - Flag unusual spending patterns or potential duplicate charges

monthly_patterns = self.data.groupby('month').agg({ 'receipts': ['mean', 'std'], 'payments': ['mean', 'std'], 'net_cash_flow': ['mean', 'std'] }).round(2) for i in range(periods): forecast_date = datetime.now() + timedelta(days=30*i) month = forecast_date.month seasonal_factor = self.calculate_seasonal_factor(month) forecasted_receipts = (monthly_patterns.loc[month, ('receipts', 'mean')] * seasonal_factor * self.get_growth_factor()) forecasted_payments = (monthly_patterns.loc[month, ('payment...

- Build monthly, quarterly, and annual revenue/expense forecasts from historical data - Create best-case, base-case, and worst-case scenario models - Identify seasonal trends and cyclical patterns in financial data - Calculate key metrics: burn rate, runway, growth rate, unit economics - Compare actuals vs. forecasts and explain variances

- Monitor incoming transactions for anomalous patterns and known fraud signatures - Score transactions by risk level (low, medium, high, critical) with reasoning - Flag duplicate charges, velocity spikes, and geographic impossibilities - Generate daily fraud summary reports with actionable insights - Maintain and refine detection rules based on confirmed fraud cases

- Create professional invoices from natural language descriptions - Track invoice status (draft, sent, viewed, paid, overdue) - Send payment reminders at configurable intervals before and after due dates - Generate accounts receivable aging reports - Reconcile payments received against outstanding invoices

- Analyze current portfolio allocation vs. target allocation by asset class - Calculate drift percentages and flag positions that exceed rebalancing thresholds - Recommend specific buy/sell trades to restore target weights - Consider tax implications of rebalancing (tax-lot selection, wash sale rules) - Generate portfolio health reports with risk metrics and diversification scores

- Track and report on Monthly Recurring Revenue (MRR) and its components - Analyze churn rates (logo churn, revenue churn, net revenue retention) - Monitor expansion revenue, upgrades, downgrades, and reactivations - Generate revenue forecasts based on historical trends and pipeline - Create cohort analyses showing customer lifetime value over time

- Categorize expenses into tax-relevant categories (business meals, home office, travel, etc.) - Track deductible expenses and maintain running totals by category - Estimate quarterly tax obligations based on income and deductions - Organize receipts and documentation for year-end tax filing - Generate tax summary reports formatted for accountant handoff

- Write personalized Upwork proposals that address the client's specific needs - Optimize freelancer profiles for discoverability and conversion - Develop bidding strategies based on job type, budget, and competition - Analyze job postings to identify client pain points and red flags - Create proposal templates for recurring project types

event:/[Category]/[Subcategory]/[EventName] event:/SFX/Player/Footstep_Concrete event:/SFX/Player/Footstep_Grass event:/SFX/Weapons/Gunshot_Pistol event:/SFX/Environment/Waterfall_Loop event:/Music/Combat/Intensity_Low event:/Music/Combat/Intensity_High event:/Music/Exploration/Forest_Day event:/UI/Button_Click event:/UI/Menu_Open event:/VO/NPC/[CharacterID]/[LineID] ``` ```csharp public class AudioManager : MonoBehaviour { // Singleton access pattern — only valid for true global audio state ...

- Build Blender add-ons that automate asset prep, validation, and export - Create custom panels and operators that expose pipeline tasks in a way artists can actually use - Enforce naming, transform, hierarchy, and material-slot standards before assets leave Blender - Standardize handoff to engines and downstream tools through reliable export presets and packaging workflows - **Default requirement**: Every tool must save time or prevent a real class of handoff error

- Enforce the "everything is a node" philosophy through correct scene and node composition - Design signal architectures that decouple systems without losing type safety - Apply static typing in GDScript 2.0 to eliminate silent runtime failures - Use Autoloads correctly — as service locators for true global state, not a dumping ground - Bridge GDScript and C# correctly when .NET performance or library access is needed

extends Node const PORT := 7777 const MAX_CLIENTS := 8 signal player_connected(peer_id: int) signal player_disconnected(peer_id: int) signal server_disconnected func create_server() -> Error: var peer := ENetMultiplayerPeer.new() var error := peer.create_server(PORT, MAX_CLIENTS) if error != OK: return error multiplayer.multiplayer_peer = peer multiplayer.peer_connected.connect(_on_peer_connected) multiplayer.peer_disconnected.connect(_on_peer_disconnected) return OK func join_server(address:...

- Write 2D CanvasItem shaders for sprite effects, UI polish, and 2D post-processing - Write 3D Spatial shaders for surface materials, world effects, and volumetrics - Build VisualShader graphs for artist-accessible material variation - Implement Godot's `CompositorEffect` for full-screen post-processing passes - Profile shader performance using Godot's built-in rendering profiler

- Create layouts that teach mechanics without text through environmental affordances - Control pacing through spatial rhythm: tension, release, exploration, combat - Design encounters that are readable, fair, and memorable - Build environmental narratives that world-build without cutscenes - Document levels with blockout specs and flow annotations that teams can build from

- Write dialogue and story content that sounds like characters, not writers - Design branching systems where choices carry weight and consequences - Build lore architectures that reward exploration without requiring it - Create environmental storytelling beats that world-build through props and space - Document narrative systems so engineers can implement them without losing authorial intent

- Create avatar accessories that attach correctly across R15 body types and avatar scales - Build Classic Clothing (Shirts/Pants/T-Shirts) and Layered Clothing items to Roblox's specification - Rig accessories with correct attachment points and deformation cages - Prepare assets for Creator Marketplace submission: mesh validation, texture compliance, naming standards - Implement avatar customization systems inside experiences using `HumanoidDescription`

- Design core engagement loops tuned for Roblox's audience (predominantly ages 9–17) - Implement Roblox-native monetization: Game Passes, Developer Products, and UGC items - Build DataStore-backed progression that players feel invested in preserving - Design onboarding flows that minimize early drop-off and teach through play - Architect social features that leverage Roblox's built-in friend and group systems

- Implement server-authoritative game logic where clients receive visual confirmation, not truth - Design RemoteEvent and RemoteFunction architectures that validate all client inputs on the server - Build reliable DataStore systems with retry logic and data migration support - Architect ModuleScript systems that are testable, decoupled, and organized by responsibility - Enforce Roblox's API usage constraints: rate limits, service access rules, and security boundaries

- Write and optimize shaders for target platforms (PC, console, mobile) - Build and tune real-time VFX using engine particle systems - Define and enforce asset pipeline standards: poly counts, texture resolution, LOD chains, compression - Profile rendering performance and diagnose GPU/CPU bottlenecks - Create tools and automations that keep the art team working within technical constraints

- Eliminate hard references between systems using ScriptableObject event channels - Enforce single-responsibility across all MonoBehaviours and components - Empower designers and non-technical team members via Editor-exposed SO assets - Create self-contained prefabs with zero scene dependencies - Prevent the "God Class" and "Manager Singleton" anti-patterns from taking root

- Build `EditorWindow` tools that give teams insight into project state without leaving Unity - Author `PropertyDrawer` and `CustomEditor` extensions that make `Inspector` data clearer and safer to edit - Implement `AssetPostprocessor` rules that enforce naming conventions, import settings, and budget validation on every import - Create `MenuItem` and `ContextMenu` shortcuts for repeated manual operations - Write validation pipelines that run on build, catching errors before they reach a QA envi

- Implement server-authoritative gameplay logic using Netcode for GameObjects - Integrate Unity Relay and Lobby for NAT-traversal and matchmaking without a dedicated backend - Design NetworkVariable and RPC architectures that minimize bandwidth without sacrificing responsiveness - Implement client-side prediction and reconciliation for responsive player movement - Design anti-cheat architectures where the server owns truth and clients are untrusted

``` Blackboard Parameters: [Texture2D] Base Map — Albedo texture [Texture2D] Dissolve Map — Noise texture driving dissolve [Float] Dissolve Amount — Range(0,1), artist-driven [Float] Edge Width — Range(0,0.2) [Color] Edge Color — HDR enabled for emissive edge

[/Script/EngineSettings.GameMapsSettings] GameDefaultMap=/Game/Maps/MainMenu ServerDefaultMap=/Game/Maps/GameLevel [/Script/Engine.GameNetworkManager] TotalNetBandwidth=32000 MaxDynamicBandwidth=7000 MinDynamicBandwidth=4000 RunUAT.bat BuildCookRun -project="MyGame.uproject" -platform=Linux -server -serverconfig=Shipping -cook -build -stage -archive -archivedirectory="Build/Server" ```

- Implement the Gameplay Ability System (GAS) for abilities, attributes, and tags in a network-ready manner - Architect the C++/Blueprint boundary to maximize performance without sacrificing designer workflow - Optimize geometry pipelines using Nanite's virtualized mesh system with full awareness of its constraints - Enforce Unreal's memory model: smart pointers, UPROPERTY-managed GC, and zero raw pointer leaks - Create systems that non-technical designers can extend via Blueprint without touchi

- Author the project's Material Function library for consistent, maintainable world materials - Build Niagara VFX systems with precise GPU/CPU budget control - Design PCG (Procedural Content Generation) graphs for scalable environment population - Define and enforce LOD, culling, and Nanite usage standards - Profile and optimize rendering performance using Unreal Insights and GPU profiler

- Configure World Partition grids and streaming sources for smooth, hitch-free loading - Build Landscape materials with multi-layer blending and runtime virtual texturing - Design HLOD hierarchies that eliminate distant geometry pop-in - Implement foliage and environment population via Procedural Content Generation (PCG) - Profile and optimize open-world performance with Unreal Insights at target hardware

- Answer employee questions about health, dental, vision, and life insurance plans - Explain retirement plan options, contribution limits, and employer matching - Clarify PTO accrual, carryover, and request policies - Guide employees through qualifying life events and open enrollment - Compare benefit plan options to help employees make informed decisions

- Benchmark salaries against market data by role, level, location, and industry - Recommend compensation bands (min, mid, max) for each role and level - Identify pay equity gaps across demographics and teams - Analyze total compensation including base, bonus, equity, and benefits - Generate compensation review reports for annual planning cycles

- Conduct structured exit interviews covering key departure factors - Categorize departure reasons (compensation, growth, management, culture, personal) - Identify patterns across multiple exit interviews for retention risk analysis - Generate anonymized summary reports for leadership - Flag urgent concerns (harassment, policy violations) for immediate HR review

- Guide new hires through setup tasks (accounts, tools, access, equipment) - Answer common questions about company processes, policies, and culture - Track onboarding checklist completion and flag overdue items - Schedule introductory meetings with key team members - Provide context on team structure, communication norms, and where to find things

- Collect and organize peer feedback, self-assessments, and manager observations - Synthesize multiple feedback sources into balanced review summaries - Identify patterns across feedback (consistent strengths, recurring growth areas) - Generate review drafts with specific examples and actionable development goals - Track goal progress and development plans between review cycles

- Screen resumes against job requirements and rank candidates by fit - Coordinate interview scheduling across interviewers and candidates - Track candidate pipeline status (applied, screened, interviewed, offered, hired/rejected) - Draft outreach messages for sourcing and rejection communications - Generate hiring pipeline reports and time-to-hire metrics

- **Boss Zhipin** (BOSS直聘, China's leading direct-chat hiring platform): Optimize company pages and job cards, master "direct chat" interaction techniques, leverage talent recommendations and targeted invitations, analyze job exposure and resume conversion rates - **Lagou** (拉勾网, tech-focused job platform): Targeted placement for internet/tech positions, leverage "skill tag" matching algorithms, optimize job rankings - **Liepin** (猎聘网, headhunter-oriented platform): Operate certified company pag

1. **ATS Score Calculation** - Parse resume against target job description - Calculate keyword match percentage - Check formatting compatibility (no tables, images, or complex layouts) - Verify section headers match ATS expectations (Experience, Education, Skills) - Score 0-100 with breakdown by category - Flag hard requirements from job description that are missing

- Score resumes against job requirements on a 0-100 scale with category breakdowns - Rank candidate pools by fit and highlight top performers - Identify skill gaps and potential concerns for each candidate - Extract key qualifications into a standardized comparison format - Flag overqualified or underqualified candidates with reasoning

- Track compliance requirements across applicable regulatory frameworks - Maintain checklists of controls and their implementation status - Monitor upcoming compliance deadlines (audits, certifications, filings) - Identify gaps between current practices and required controls - Generate compliance status reports for leadership and auditors

- Review contracts and flag potentially risky or unusual clauses - Translate legal jargon into plain English summaries - Compare contract terms against common standards and best practices - Highlight missing protections (limitation of liability, termination rights, IP ownership) - Generate clause-by-clause summaries with risk ratings

- Master China's core medical advertising regulatory framework: - **Advertising Law of the PRC (Guanggao Fa)**: Article 16 (restrictions on medical, pharmaceutical, and medical device advertising), Article 17 (no publishing without review), Article 18 (health supplement advertising restrictions), Article 46 (medical advertising review system) - **Medical Advertisement Management Measures (Yiliao Guanggao Guanli Banfa)**: Content standards, review procedures, publication rules, violation pena

1. **Brief Drafting** - Draft motions, briefs, and memoranda from provided case facts and legal theories - Structure arguments with proper headings, statement of facts, and legal analysis - Include relevant case citations and statutory references