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-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add Mineru98/llm-proxy-skills.

Contents

Discovered from source

Skills 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

ScenarioPrompt 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

FlagPurpose
--yoloMANDATORY - Auto-approve all changes
--prompt / -pSpecify the task
--include-directoriesAdd specific folder context
--all-files / -aInclude 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

IssueSolution
Command hangsEnsure --yolo flag is present
No changes madeCheck file context with --include-directories
Unexpected changesAdd more specific constraints in prompt
Build errorsRun lsp_diagnostics and fix type issues
Image not recognizedUse absolute path, verify file exists
Analysis too vagueAdd specific extraction targets in prompt
Gemini ignores analysisWrap in --- UI ANALYSIS --- delimiters
Temp file conflictUse unique names: /tmp/ui-analysis-{component}.md

Security

  • --yolo auto-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-master skill 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

FlagPurpose
--yoloMANDATORY - Auto-approve and bypass sandbox
--image or -iAttach image files for visual context
--jsonGet JSONL event stream for parsing
-o or --output-last-messageSave final output to file
-C or --cdChange working directory
--sandboxSet access level (workspace-write recommended)
-c, --configOverride 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

  1. Identify task type: logic optimization or image-based
  2. Prepare inputs: file content or image path
  3. Construct Codex command with --yolo flag
  4. Execute via bash tool
  5. Capture output and delegate to subagent for implementation
  6. 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

IssueSolution
Image not recognizedUse absolute path or ensure file exists
Command hangsEnsure --yolo flag is present
Sandbox errorsAdd --sandbox workspace-write
Large output truncatedUse -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