
llm-proxy-skills
logic-master (Codex) and frontend-master (Gemini) skills for code optimization and UI/UX tasks
- version
- 1.0.1
Install
/plugin install llm-proxy-skills@llm-proxy-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add Mineru98/llm-proxy-skills.
Contents
Discovered from sourceSkills 2
Frontend Master Skill
Frontend UI/UX implementation workflow using Gemini CLI in --yolo mode.
For image-based tasks, Gemini analyzes the image first, then implements based on that analysis.
Routing Rules
USE this skill
- Visual properties: colors, backgrounds, borders, shadows
- Layout: flexbox, grid, margins, padding, positioning
- Typography: font sizes, weights, line heights
- Animation: transitions, keyframes, hover states
- Responsive design: breakpoints, media queries
- Component styling: Tailwind, CSS-in-JS, styled-components
- Image-based frontend: generate/modify components from screenshots, mockups, design exports
DO NOT use this skill
- Pure logic: API calls, state management, event handlers
- Type definitions, utility functions, business logic
- Logic optimization or non-frontend image tasks → use
logic-master
Workflow
Task received
│
▼
┌──────────┐ ┌─────────────────┐ ┌──────────────┐ ┌────────────┐
│ Image │ Yes │ Phase 1: │ │ Phase 2: │ │ Verify │
│ input ├────►│ Gemini image ├────►│ Gemini ├────►│ lsp_diag │
│ exists? │ │ analysis (@ref) │ │ --yolo impl │ │ nostics │
└────┬─────┘ └─────────────────┘ └──────┬───────┘ └────────────┘
│ No ▲
└──────────────────────────────────────────┘
Step 1: Detect image input
Check if the task includes image files (.png, .jpg, .jpeg, .webp, .gif, .svg, .pdf).
Step 2: Branch execution
Image exists → 2-phase pipeline (Phase 1 → Phase 2) No image → Direct execution (Phase 2 only)
Step 3: Verify results
Run lsp_diagnostics to check for type/build errors and fix them.
Phase 1: Gemini Image Analysis
Reference image paths with @ to extract UI structure. Save results to a temp file.
ANALYSIS_PROMPT=$(cat <<'PROMPT'
@<image-path>
Analyze this UI image and organize in the following format:
1. LAYOUT: Overall layout structure (flex/grid, direction, alignment)
2. COMPONENTS: UI component list and hierarchy
3. COLORS: Color palette (hex codes)
4. TYPOGRAPHY: Font sizes, weights, line heights
5. SPACING: Margins, padding, gap values (px/rem estimates)
6. INTERACTIONS: Buttons, links, hover states and interactive elements
7. RESPONSIVE: Responsive design considerations
PROMPT
)
gemini --yolo -p "$ANALYSIS_PROMPT" > /tmp/ui-analysis.md
Analysis Prompt Variants
| Scenario | Prompt focus |
|---|---|
| Simple component | @<img> + map to Tailwind classes |
| Complex layout | @<img> + detailed hierarchy, grid system, spacing |
| Before/After comparison | @<before> @<after> + diff changes in CSS/Tailwind |
| Responsive comparison | @<desktop> @<mobile> + breakpoint differences |
| Design system extraction | @<img> + map to color/typo/spacing tokens |
| Error screenshot | @<img> + identify rendering issues and CSS fixes |
Single Component Analysis
ANALYSIS_PROMPT=$(cat <<'PROMPT'
@<image-path>
Focus only on the [component-name] section. Analyze and map to Tailwind CSS classes.
PROMPT
)
gemini --yolo -p "$ANALYSIS_PROMPT" > /tmp/ui-analysis.md
Multi-Image Analysis
ANALYSIS_PROMPT=$(cat <<'PROMPT'
@<desktop.png> @<mobile.png>
Compare and analyze both images:
1. Desktop layout structure
2. Mobile layout structure
3. Responsive transition points
4. Common and differing elements
5. Tailwind breakpoint mapping
PROMPT
)
gemini --yolo -p "$ANALYSIS_PROMPT" > /tmp/ui-analysis.md
Phase 2: Gemini --yolo Implementation
With image analysis results
Inject analysis into the implementation prompt.
ANALYSIS=$(cat /tmp/ui-analysis.md)
gemini --yolo -p "Implement based on the following UI analysis:
--- UI ANALYSIS ---
${ANALYSIS}
--- END ANALYSIS ---
Implementation requirements:
- Follow existing CSS framework/patterns in the project
- Use semantic HTML structure
- Include responsive design
- Consider accessibility (a11y)
Target file: <target-file-path>" \
--include-directories <relevant-dirs>
Direct execution (no image)
# With file context
cat <frontend-file> | gemini --yolo -p "<instruction>"
# With directory context
gemini --yolo -p "<instruction>" --include-directories <dirs>
# With full project context
gemini --yolo -p "<instruction>" --all-files
Required Flags
| Flag | Purpose |
|---|---|
--yolo | MANDATORY - Auto-approve all changes |
--prompt / -p | Specify the task |
--include-directories | Add specific folder context |
--all-files / -a | Include full project context |
Examples
Component Styling
# Update button styles
cat src/components/Button.tsx | gemini --yolo -p "Change button color to blue-500, add hover:scale-105 transition"
# Responsive navbar
gemini --yolo -p "Make the navbar responsive with hamburger menu on mobile" --include-directories src/components
Layout Changes
# Convert to grid layout
cat src/pages/Dashboard.tsx | gemini --yolo -p "Convert this layout to CSS Grid with 3 columns"
Animation
# Modal fade-in
cat src/components/Modal.tsx | gemini --yolo -p "Add fade-in animation when modal opens"
Full Project Changes
# Dark mode
gemini --yolo -p "Update all components to use dark mode color palette" --all-files
Image-Based Full Pipeline
# Phase 1: Analyze mockup
ANALYSIS_PROMPT=$(cat <<'PROMPT'
@designs/card-component.png
Analyze this card component:
1. Layout structure (flex/grid)
2. Size, color, spacing of each element
3. Tailwind CSS class mapping
4. Estimated hover/interaction states
PROMPT
)
gemini --yolo -p "$ANALYSIS_PROMPT" > /tmp/ui-analysis.md
# Phase 2: Implement
ANALYSIS=$(cat /tmp/ui-analysis.md)
gemini --yolo -p "Implement a React component based on the following analysis:
--- UI ANALYSIS ---
${ANALYSIS}
--- END ANALYSIS ---
- Create at src/components/Card.tsx
- Use Tailwind CSS
- Include TypeScript props interface
- Follow existing component patterns" \
--include-directories src/components
Subagent Delegation Templates
Standard Frontend Task
1. TASK: Update component styling via Gemini CLI
2. EXPECTED OUTCOME: Visually updated component
3. REQUIRED TOOLS: Bash (gemini CLI), Read, lsp_diagnostics
4. MUST DO:
- Use --yolo flag
- Verify with lsp_diagnostics after execution
- Follow existing CSS framework patterns
5. MUST NOT DO:
- Modify logic or event handlers
- Remove existing functionality
6. CONTEXT: [file paths, design requirements, existing patterns]
Image-Based Frontend Task
1. TASK: Generate/modify component from image reference
2. EXPECTED OUTCOME: Component matching the visual reference
3. REQUIRED TOOLS: Bash (gemini CLI), Read, Edit, lsp_diagnostics
4. MUST DO:
- Phase 1: Run Gemini with @-image prompt → save to /tmp/ui-analysis.md
- Phase 2: Inject analysis into gemini --yolo prompt
- Verify with lsp_diagnostics
- Clean up temp files after completion
5. MUST NOT DO:
- Skip image analysis phase
- Modify business logic
6. CONTEXT: [image path, target file, existing patterns]
Troubleshooting
| Issue | Solution |
|---|---|
| Command hangs | Ensure --yolo flag is present |
| No changes made | Check file context with --include-directories |
| Unexpected changes | Add more specific constraints in prompt |
| Build errors | Run lsp_diagnostics and fix type issues |
| Image not recognized | Use absolute path, verify file exists |
| Analysis too vague | Add specific extraction targets in prompt |
| Gemini ignores analysis | Wrap in --- UI ANALYSIS --- delimiters |
| Temp file conflict | Use unique names: /tmp/ui-analysis-{component}.md |
Security
--yoloauto-approves ALL changes. Use only in version-controlled directories.- Image files referenced by
@paths are processed in Gemini CLI context. Verify path access policy before running.
Codex Logic Skill
Execute logic optimization and image-based code tasks using Codex CLI in --yolo mode.
When to Use
- Logic optimization: algorithm improvements, performance tuning
- Image-based tasks: generate code from screenshots, mockups, diagrams
- Refactoring: extract functions, simplify conditionals, reduce complexity
- Business logic: validation rules, data transformations, state machines
- Debugging: fix complex logic bugs, race conditions
When NOT to Use
- Visual/styling changes (use
frontend-masterskill instead) - CSS, layout, colors, typography, animations
Execution Pattern
Basic Command Structure
# Direct prompt
codex exec --yolo "<instruction>"
# With file context via stdin
cat <file> | codex exec --yolo -
# With image attachment
codex exec --yolo --image <path-to-image> "<instruction>"
# With directory context
codex exec --yolo -C <directory> "<instruction>"
Required Flags
| Flag | Purpose |
|---|---|
--yolo | MANDATORY - Auto-approve and bypass sandbox |
--image or -i | Attach image files for visual context |
--json | Get JSONL event stream for parsing |
-o or --output-last-message | Save final output to file |
-C or --cd | Change working directory |
--sandbox | Set access level (workspace-write recommended) |
-c, --config | Override config value; for this skill, only model_reasoning_effort should be adjusted (예: -c model_reasoning_effort="xhigh") |
Model Routing (Performance-oriented)
- **이미지 기반 작업(
--image사용)**은 반드시gpt-5.3-codex사용. - 이미지 미사용 작업은 가벼운 요청에서는
gpt-5.3-codex-spark사용. - 복잡/대규모/고난도 작업은
gpt-5.3-codex사용. - 모델 자체는 전환하지 않고, 조절은
model_reasoning_effort만 수행.
실무 예시:
codex exec --yolo --image screenshot.png -c model_reasoning_effort=\"xhigh\" "Analyze image context"
codex exec --yolo -c model_reasoning_effort=\"low\" "Refactor a small utility function"
codex exec --yolo -c model_reasoning_effort=\"xhigh\" "Redesign a complex scheduling algorithm"
Workflow
- Identify task type: logic optimization or image-based
- Prepare inputs: file content or image path
- Construct Codex command with
--yoloflag - Execute via bash tool
- Capture output and delegate to subagent for implementation
- Verify results with
lsp_diagnostics
Image-Based Tasks
Generate Code from Screenshot
# UI mockup to component
codex exec --yolo --image mockup.png "Generate React component matching this design"
# Diagram to code
codex exec --yolo --image architecture.png "Implement the data flow shown in this diagram"
# Error screenshot to fix
codex exec --yolo --image error-screenshot.png "Analyze this error and provide fix"
Multiple Images
codex exec --yolo --image before.png --image after.png "Generate code to transform UI from before to after state"
Logic Optimization Tasks
Algorithm Optimization
# Optimize function
cat src/utils/sort.ts | codex exec --yolo - "Optimize this sorting algorithm for large datasets"
# Reduce complexity
cat src/services/parser.ts | codex exec --yolo - "Refactor to reduce cyclomatic complexity"
Refactoring
# Extract functions
cat src/handlers/user.ts | codex exec --yolo - "Extract reusable validation logic into separate functions"
# Simplify conditionals
cat src/logic/pricing.ts | codex exec --yolo - "Simplify nested conditionals using early returns"
Performance Tuning
# Memory optimization
cat src/data/processor.ts | codex exec --yolo - "Optimize memory usage, avoid unnecessary allocations"
# Async optimization
codex exec --yolo -C src/services "Identify and fix N+1 query patterns"
Output Handling
JSON Output for Parsing
codex exec --yolo --json "Generate utility function" | jq -r '.content'
Save to File
codex exec --yolo -o result.ts "Generate TypeScript interface from this JSON schema"
Resume Session
# Continue previous work
codex exec resume --last "Apply the suggested changes"
Integration with Subagents
After Codex CLI provides analysis/suggestions, delegate implementation:
1. TASK: Implement logic changes based on Codex analysis
2. EXPECTED OUTCOME: Optimized code matching Codex recommendations
3. REQUIRED SKILLS: logic-master
4. REQUIRED TOOLS: Bash (for codex CLI), Read, Edit, lsp_diagnostics
5. MUST DO:
- Execute codex exec with --yolo flag first
- Parse Codex output for implementation steps
- Apply changes using Edit tool
- Verify with lsp_diagnostics
- Run tests if available
6. MUST NOT DO:
- Modify styling/visual elements
- Skip verification step
- Ignore Codex warnings or caveats
7. CONTEXT: [file paths, performance requirements, constraints]
Image-Based Workflow Example
1. TASK: Generate component from design mockup
2. EXPECTED OUTCOME: Working React component matching mockup
3. REQUIRED SKILLS: logic-master
4. REQUIRED TOOLS: Bash (for codex CLI), Write, lsp_diagnostics
5. MUST DO:
- Use codex exec --yolo --image <path> to analyze mockup
- Create component based on Codex output
- Match existing component patterns in codebase
- Verify types with lsp_diagnostics
6. MUST NOT DO:
- Generate inline styles (use existing CSS framework)
- Create new dependencies without approval
7. CONTEXT: [mockup path, component location, existing patterns]
Example Complete Workflow
# Step 1: Analyze image and get code suggestion
codex exec --yolo --image ui-mockup.png "Analyze this mockup and describe the React component structure needed" -o analysis.md
# Step 2: Generate implementation
codex exec --yolo --image ui-mockup.png "Generate React component code for this mockup using Tailwind CSS" -o Component.tsx
# Step 3: Verify and integrate
# (delegate to subagent to place file, add imports, run diagnostics)
Troubleshooting
| Issue | Solution |
|---|---|
| Image not recognized | Use absolute path or ensure file exists |
| Command hangs | Ensure --yolo flag is present |
| Sandbox errors | Add --sandbox workspace-write |
| Large output truncated | Use -o <file> to save full output |
| 모델 품질/속도 조절 | 과도한 결과 변동이 있으면 model_reasoning_effort (low, medium, high, xhigh) 값만 조정 |
Security Note
--yolo mode bypasses approval and sandbox restrictions. Use only when:
- Working in version-controlled directories
- Changes can be easily reverted
- No sensitive operations or credentials involved
- Running in isolated development environment
Sponsors
Details
- Marketplace
- Mineru98/llm-proxy-skills
- Author
- Mineru
- Category
- Development