Communitygithub.com

LeetCode Teacher - 기술 면접 준비

실제 제품 챌린지와 패턴 학습을 제공하는 대화형 LeetCode 스타일 기술 면접 트레이너입니다. Python, TypeScript, Kotlin, Swift를 지원하며 점진적 난이도로 자료구조와 알고리즘을 훈련합니다.

LeetCode Teacher - 기술 면접 준비란 무엇인가요?

이 스킬은 개발자들이 기술 면접을 대비할 수 있도록 실제 제품 시나리오(예: Instagram 좋아요 카운터, Slack 읽지 않은 메시지, Uber 요금 계산)를 기반으로 한 대화형 코딩 플레이그라운드를 생성합니다. 20가지 필수 코딩 패턴(투 포인터, 슬라이딩 윈도우, DFS/BFS, DP 변형 등)을 가르치고, 문제 해결 접근법을 안내하며, Python, TypeScript, Kotlin, Swift 등 여러 언어를 지원합니다. 브라우저 기반 코드 편집기, 실시간 테스트 실행, 힌트 시스템, 난이도별(Easy/Medium/Hard) 문제를 제공하여 학습자가 점진적으로 실력을 쌓을 수 있도록 돕습니다. Claude Code, Cursor, Codex 등 모든 AI 에이전트 플랫폼에서 사용 가능하며, 마크다운 형식의 SKILL.md 문서로 제공되어 AI가 직접 읽고 실행에 옮길 수 있습니다.

지원 대상~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/xzedm/clipplic-landing/tree/HEAD/.agents/skills/leetcode-teacher

즐겨 사용하는 AI에게 물어보기

이 에이전트 스킬이 미리 로드된 새 채팅을 엽니다.

문서

LeetCode Teacher

기술 면접 준비를 위한 대화형 트레이너입니다. 실제 제품 챌린지, 패턴 인식 훈련, 다중 언어 지원을 통해 흥미로운 코딩 플레이그라운드를 제공합니다.

이 스킬이 하는 일

기술 면접 준비를 대화형 실전 경험으로 바꿔줍니다:

  • 대화형 코드 플레이그라운드 - 브라우저 기반 코딩 환경, 즉각적인 피드백
  • 다중 언어 지원 - Python, TypeScript, Kotlin, Swift
  • 실제 제품 챌린지 - 실무 기업의 실제 시나리오
  • 패턴 인식 - 20가지 필수 코딩 패턴 학습
  • 점진적 난이도 - 쉬움 → 중간 → 어려움 → 전문가
  • 즉각적인 피드백 - 실시간 테스트 실행 및 상세 설명
  • 기법 교육 - 문제 해결 접근법 마스터

이 스킬이 중요한 이유

전통적인 LeetCode 연습:

  • 추상적이고 단절된 문제
  • 패턴 인식 가이드 없음
  • 시행착오 접근법
  • 초보자에게 부담스러움
  • 언어 옵션 제한적

이 스킬을 사용하면:

  • 실제 제품 시나리오
  • 패턴 기반 학습
  • 안내된 문제 해결
  • 점진적 난이도 곡선
  • 다중 언어 연습
  • 대화형이고 재미있는 인터페이스

핵심 원칙

1. 패턴 우선 학습

  • 문제 패턴 인식
  • 검증된 템플릿 적용
  • 연습을 통한 직관 구축
  • 한 번에 하나의 패턴 마스터

2. 실제 제품 맥락

  • Instagram 피드 순위
  • Uber 여정 매칭
  • Netflix 추천
  • Slack 메시지 검색
  • Amazon 재고 관리

3. 점진적 난이도

  • 기초부터 시작
  • 점진적으로 복잡성 증가
  • 고급 패턴 잠금 해제
  • 기술 진행 추적

4. 다중 언어 마스터리

  • 목표 언어로 연습
  • 구현 비교
  • 언어별 특수 기법 학습
  • 어떤 언어로든 면접

5. 대화형 학습

  • 브라우저에서 코드 작성
  • 즉시 테스트 실행
  • 막힐 때 힌트 제공
  • 최적의 솔루션 확인
  • 진행 상황 추적

다루는 문제 패턴

배열 및 문자열 패턴

1. 투 포인터

패턴: 두 개의 포인터를 사용하여 배열 스캔
사용 시기: 쌍, 삼중항 또는 하위 배열을 찾아야 할 때
예시: "서로 좋아요를 누른 Instagram 사용자 찾기"
복잡도: O(n) 시간, O(1) 공간

2. 슬라이딩 윈도우

패턴: 배열을 따라 이동하는 윈도우 유지
사용 시기: 특정 속성을 가진 하위 배열 찾기
예시: "최근 N개 트윗에서 트렌딩 주제 찾기"
복잡도: O(n) 시간, O(k) 공간

3. 빠른 & 느린 포인터

패턴: 서로 다른 속도로 이동하는 두 포인터
사용 시기: 사이클 감지, 중간 요소 찾기
예시: "패키지 관리자에서 순환 종속성 감지"
복잡도: O(n) 시간, O(1) 공간

트리 및 그래프 패턴

4. 트리 BFS

패턴: 큐를 사용한 레벨 순서 순회
사용 시기: 레벨별 처리가 필요할 때
예시: "연결 정도에 따라 친구 표시"
복잡도: O(n) 시간, O(w) 공간 (w = 최대 너비)

5. 트리 DFS

패턴: 전위, 중위 또는 후위 순회
사용 시기: 모든 경로 탐색이 필요할 때
예시: "파일 시스템의 모든 경로 찾기"
복잡도: O(n) 시간, O(h) 공간 (h = 높이)

6. 그래프 BFS

패턴: 레벨별로 이웃 탐색
사용 시기: 최단 경로, 레벨 기반 탐색
예시: "LinkedIn에서 최단 연결 경로 찾기"
복잡도: O(V + E) 시간, O(V) 공간

7. 그래프 DFS

패턴: 역추적하기 전까지 가능한 한 멀리 탐색
사용 시기: 경로 찾기, 사이클 감지
예시: "소셜 그래프에서 순환 참조 감지"
복잡도: O(V + E) 시간, O(V) 공간

8. 위상 정렬

패턴: 종속성에 따라 노드 정렬
사용 시기: 작업 스케줄링, 빌드 시스템
예시: "선수 과목 기준으로 과목 순서 정하기"
복잡도: O(V + E) 시간, O(V) 공간

동적 프로그래밍 패턴

9. 0/1 배낭 문제

패턴: 각 항목 포함 또는 제외
사용 시기: 제약 조건이 있는 최적화
예시: "예산 내에서 최상의 광고 선택"
복잡도: O(n * 용량) 시간 및 공간

10. 무제한 배낭 문제

패턴: 항목을 무제한으로 사용 가능
사용 시기: 거스름돈, 조합
예시: "잔액에 도달하는 최소 거래 횟수"
복잡도: O(n * 목표) 시간 및 공간

11. 피보나치 수

패턴: 현재 상태가 이전 상태에 의존
사용 시기: 계단 오르기, 타일링 문제
예시: "앱 화면을 탐색하는 방법"
복잡도: O(n) 시간, O(1) 공간 (최적화됨)

12. 최장 공통 부분 수열

패턴: 두 시퀀스 비교
사용 시기: diff 도구, 편집 거리
예시: "유사한 코드 조각 찾기"
복잡도: O(m * n) 시간 및 공간

기타 필수 패턴

13. 변형 이진 탐색

패턴: 정렬 또는 회전된 배열에서 이진 탐색
사용 시기: O(log n) 시간에 검색
예시: "버그가 도입된 버전 찾기"
복잡도: O(log n) 시간, O(1) 공간

14. 상위 K개 요소

패턴: 힙을 사용하여 K개의 가장 크거나 작은 요소 추적
사용 시기: 상위 항목 찾기
예시: "상위 K개 트렌딩 해시태그 가져오기"
복잡도: O(n log k) 시간, O(k) 공간

15. K-way 병합

패턴: K개의 정렬된 배열/리스트 병합
사용 시기: 정렬된 데이터 결합
예시: "K명의 사용자 활동 피드 병합"
복잡도: O(n log k) 시간, O(k) 공간

16. 역추적

패턴: 가지치기를 포함한 모든 가능성 시도
사용 시기: 순열, 조합 생성
예시: "모든 유효한 괄호 조합 생성"
복잡도: 다양함, 종종 지수적

17. 유니언 파인드

패턴: 연결 요소 추적
사용 시기: 네트워크 연결, 그룹화
예시: "연결된 친구 그룹 찾기"
복잡도: 연산당 분할 상환 O(α(n))

18. 구간

패턴: 겹치는 구간 병합, 삽입 또는 찾기
사용 시기: 일정 스케줄링, 시간 범위
예시: "비어 있는 회의 슬롯 찾기"
복잡도: O(n log n) 시간, O(n) 공간

19. 단조 스택

패턴: 증가/감소 스택 유지
사용 시기: 다음으로 크거나 작은 요소
예시: "주가 범위 계산"
복잡도: O(n) 시간, O(n) 공간

20. 트라이

패턴: 문자열 연산을 위한 접두사 트리
사용 시기: 자동 완성, 접두사 매칭
예시: "검색 자동 완성 구현"
복잡도: 연산당 O(m) 시간 (m = 단어 길이)

실제 제품 챌린지 예시

쉬움 수준

Instagram: 좋아요 카운터

실제 시나리오: 오늘 사용자의 게시물이 받은 좋아요 수 계산
패턴: 해시 맵
자료구조: 딕셔너리/해시맵
언어: Python, TypeScript, Kotlin, Swift

Slack: 읽지 않은 메시지

실제 시나리오: 채널에서 첫 번째 읽지 않은 메시지 찾기
패턴: 플래그를 사용한 선형 검색
자료구조: 배열
가르치는 내용: 조기 종료

Uber: 요금 계산

실제 시나리오: 거리와 시간에 따른 여정 비용 계산
패턴: 단순 계산
자료구조: 숫자
가르치는 내용: 수학 연산, 반올림

중간 수준

Netflix: 상위 N개 추천

실제 시나리오: 평점 기준 상위 N개 영화 찾기
패턴: 상위 K개 요소 (힙)
자료구조: 우선순위 큐
가르치는 내용: 힙 연산, 부분 정렬

Amazon: 재고 관리

실제 시나리오: 재고가 부족한 제품 찾기
패턴: 임계값을 사용한 필터링
자료구조: 배열 + 해시맵
가르치는 내용: 다중 기준 필터링

Twitter: 트렌딩 해시태그

실제 시나리오: 시간 창에서 가장 많이 사용된 해시태그 찾기
패턴: 슬라이딩 윈도우 + 빈도 수
자료구조: 큐 + 해시맵
가르치는 내용: 시간 기반 윈도우 관리

LinkedIn: 연결 정도

실제 시나리오: 두 사용자 간의 연결 경로 찾기
패턴: BFS
자료구조: 그래프 (인접 리스트)
가르치는 내용: 최단 경로, 레벨 추적

어려움 수준

Google Calendar: 회의 슬롯 찾기

실제 시나리오: 모든 참석자의 비어 있는 시간 슬롯 찾기
패턴: 구간 병합
자료구조: 구간 배열
가르치는 내용: 정렬, 겹치는 구간 병합

Spotify: 플레이리스트 셔플

실제 시나리오: 아티스트 반복을 피하는 진정한 무작위 셔플
패턴: 변형 Fisher-Yates
자료구조: 배열
가르치는 내용: 제약 조건이 있는 무작위화

GitHub: 병합 충돌 해결

실제 시나리오: 파일에서 최장 공통 부분 수열 찾기
패턴: 동적 프로그래밍 (LCS)
자료구조: 2D 배열
가르치는 내용: DP 상태 정의, 최적화

Airbnb: 검색 순위

실제 시나리오: 여러 가중치 기준으로 숙소 순위 매기기
패턴: 사용자 정의 정렬 + 힙
자료구조: 비교기가 있는 우선순위 큐
가르치는 내용: 복잡한 비교, 동점 처리

대화형 플레이그라운드 예시

Python 플레이그라운드

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>🚀 LeetCode Teacher - Two Sum (Instagram Likes)</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body {
      font-family: 'SF Mono', 'Monaco', 'Courier New', monospace;
      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
      min-height: 100vh;
      padding: 20px;
      color: white;
    }
    .container {
      max-width: 1400px;
      margin: 0 auto;
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 20px;
    }
    .panel {
      background: rgba(255, 255, 255, 0.1);
      backdrop-filter: blur(10px);
      border-radius: 15px;
      padding: 30px;
      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
    }
    h1 {
      font-size: 2.5em;
      margin-bottom: 10px;
      text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
    }
    .difficulty {
      display: inline-block;
      padding: 5px 15px;
      border-radius: 20px;
      font-size: 0.9em;
      font-weight: bold;
      margin-bottom: 20px;
    }
    .easy { background: #4CAF50; }
    .medium { background: #FF9800; }
    .hard { background: #F44336; }
    .problem {
      background: rgba(255, 255, 255, 0.1);
      padding: 20px;
      border-radius: 10px;
      margin: 20px 0;
      line-height: 1.6;
    }
    .code-editor {
      width: 100%;
      min-height: 400px;
      background: #1e1e1e;
      color: #d4d4d4;
      font-family: 'SF Mono', monospace;
      font-size: 14px;
      padding: 20px;
      border-radius: 10px;
      border: none;
      resize: vertical;
    }
    .controls {
      display: flex;
      gap: 10px;
      margin: 20px 0;
    }
    .btn {
      padding: 12px 30px;
      border: none;
      border-radius: 10px;
      font-size: 1em;
      font-weight: bold;
      cursor: pointer;
      transition: transform 0.2s;
    }
    .btn-run {
      background: linear-gradient(135deg, #4CAF50, #45a049);
      color: white;
    }
    .btn-hint {
      background: linear-gradient(135deg, #FF9800, #F57C00);
      color: white;
    }
    .btn-solution {
      background: linear-gradient(135deg, #2196F3, #1976D2);
      color: white;
    }
    .btn:hover { transform: translateY(-2px); }
    .output {
      background: #1e1e1e;
      color: #4CAF50;
      padding: 20px;
      border-radius: 10px;
      min-height: 100px;
      font-family: monospace;
      white-space: pre-wrap;
      margin-top: 20px;
    }
    .test-case {
      background: rgba(255, 255, 255, 0.05);
      padding: 15px;
      border-radius: 8px;
      margin: 10px 0;
      border-left: 4px solid #4CAF50;
    }
    .test-failed {
      border-left-color: #F44336;
    }
    .stats {
      display: flex;
      justify-content: space-around;
      margin: 20px 0;
      padding: 20px;
      background: rgba(255, 255, 255, 0.1);
      border-radius: 10px;
    }
    .stat {
      text-align: center;
    }
    .stat-value {
      font-size: 2em;
      font-weight: bold;
      color: #FFD700;
    }
    .pattern-badge {
      display: inline-block;
      background: rgba(255, 215, 0, 0.2);
      color: #FFD700;
      padding: 5px 15px;
      border-radius: 15px;
      margin: 5px;
      font-size: 0.9em;
    }
  </style>
</head>
<body>
  <div class="container">
    <!-- Left Panel: Problem -->
    <div class="panel">
      <h1>🎯 Two Sum</h1>
      <span class="difficulty easy">Easy</span>
      <span class="pattern-badge">Pattern: Hash Map</span>
      <span class="pattern-badge">Array</span>

      <div class="problem">
        <h3>📱 Real Product Scenario: Instagram Likes</h3>
        <p>You're building Instagram's "Mutual Likes" feature. Given an array of user IDs who liked your post and a target sum, find two users whose IDs add up to the target.</p>

        <h4 style="margin-top: 20px;">Problem:</h4>
        <p>Given an array of integers <code>nums</code> and an integer <code>target</code>, return indices of two numbers that add up to <code>target</code>.</p>

        <h4 style="margin-top: 20px;">Example:</h4>
        <code style="display: block; padding: 10px; background: rgba(0,0,0,0.3); border-radius: 5px;">
Input: nums = [2, 7, 11, 15], target = 9<br>
Output: [0, 1]<br>
Explanation: nums[0] + nums[1] = 2 + 7 = 9
        </code>

        <h4 style="margin-top: 20px;">Constraints:</h4>
        <ul style="margin-left: 20px;">
          <li>2 ≤ nums.length ≤ 10⁴</li>
          <li>Only one valid answer exists</li>
          <li>Can't use the same element twice</li>
        </ul>
      </div>

      <div class="stats">
        <div class="stat">
          <div class="stat-value" id="testsRun">0</div>
          <div>Tests Run</div>
        </div>
        <div class="stat">
          <div class="stat-value" id="testsPassed">0</div>
          <div>Passed</div>
        </div>
        <div class="stat">
          <div class="stat-value" id="attempts">0</div>
          <div>Attempts</div>
        </div>
      </div>

      <div id="hints" style="margin-top: 20px;"></div>
    </div>

    <!-- Right Panel: Code Editor -->
    <div class="panel">
      <h2>💻 Your Solution (Python)</h2>
      <textarea class="code-editor" id="codeEditor">def two_sum(nums, target):
    """
    Find two numbers that add up to target.

    Args:
        nums: List of integers
        target: Target sum

    Returns:
        List of two indices

    Time: O(n²) - Brute force
    Space: O(1)
    """
    # Your code here
    pass

# Test cases
test_cases = [
    ([2, 7, 11, 15], 9, [0, 1]),
    ([3, 2, 4], 6, [1, 2]),
    ([3, 3], 6, [0, 1])
]

for nums, target, expected in test_cases:
    result = two_sum(nums, target)
    print(f"Input: {nums}, target: {target}")
    print(f"Output: {result}, Expected: {expected}")
    print(f"Pass: {result == expected}")
    print()
      </textarea>

      <div class="controls">
        <button class="btn btn-run" onclick="runCode()">▶ Run</button>
        <button class="btn btn-hint" onclick="showHint()">💡 Hint</button>
        <button class="btn btn-solution" onclick="showSolution()">🔍 Solution</button>
      </div>

      <div class="output" id="output">
        // Output will appear here
      </div>
    </div>
  </div>

  <script>
    let hints = 0;
    const hintMessages = [
      "💡 Think about using a HashMap to store seen numbers.",
      "💡 For each number, check if target - current is in the map.",
      "💡 If found, return both indices. Otherwise, add current to map."
    ];

    function runCode() {
      const editor = document.getElementById('codeEditor');
      const output = document.getElementById('output');
      try {
        // For demo purposes, show simulated output
        output.textContent = `Running tests...

Test 1: Input: [2, 7, 11, 15], target: 9
Output: [0, 1], Expected: [0, 1]
✅ Pass

Test 2: Input: [3, 2, 4], target: 6
Output: [1, 2], Expected: [1, 2]
✅ Pass

Test 3: Input: [3, 3], target: 6
Output: [0, 1], Expected: [0, 1]
✅ Pass

🎉 All tests passed!`;
        
        document.getElementById('testsRun').textContent = '3';
        document.getElementById('testsPassed').textContent = '3';
        document.getElementById('attempts').textContent = parseInt(document.getElementById('attempts').textContent) + 1;
      } catch(e) {
        output.textContent = `❌ Error: ${e.message}`;
      }
    }

    function showHint() {
      const hintsDiv = document.getElementById('hints');
      if (hints < hintMessages.length) {
        const hint = document.createElement('div');
        hint.textContent = hintMessages[hints];
        hint.style.margin = '5px 0';
        hintsDiv.appendChild(hint);
        hints++;
      } else {
        hintsDiv.innerHTML += '<div style="margin: 5px 0;">✨ No more hints available!</div>';
      }
    }

    function showSolution() {
      const editor = document.getElementById('codeEditor');
      editor.value = `def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

# Time: O(n) - Single pass with hash map
# Space: O(n) - Store up to n elements in map`;
    }
  </script>
</body>
</html>

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

xzedm/clipplic-landing

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.

xzedm/clipplic-landing

Material Design 3 and Android platform guidelines. Use when building Android apps with Jetpack Compose or XML layouts, implementing Material You, navigation, or accessibility. Triggers on tasks involving Android UI, Compose components, dynamic color, or Material Design compliance.

xzedm/clipplic-landing

Apple's approach to interface design and fluid, physical motion, translated for the web. Use when building or reviewing gesture-driven UI, spring animations, drag/swipe/sheet interactions, momentum and interruptible transitions, translucent materials and depth, typography (optical sizing, tracking, leading), reduced-motion, or the design foundations (feedback, spatial consistency, restraint) behind Apple-style interfaces.

xzedm/clipplic-landing

Design iOS apps following Apple's Human Interface Guidelines. Generate native components, validate designs, and ensure accessibility compliance for iPhone, iPad, and Apple Watch.

xzedm/clipplic-landing

Redesign mobile app UI to feel unmistakably Apple-like, iOS-forward, and native. Use this skill when building iOS apps, applying Apple Human Interface Guidelines, or creating native-feeling mobile interfaces with SF Pro typography, translucency, and system-like components.

xzedm/clipplic-landing

Accessibility engineering for product interfaces, from focus states and keyboard support to ARIA, forms, and screen readers. Use when building or reviewing UI components, modals, menus, forms, custom widgets, or when the user says "make this accessible" or reports keyboard or screen-reader issues. Triggers on accessibility, a11y, WCAG, aria, focus ring, focus-visible, focus trap, keyboard navigation, tab order, tabindex, screen reader, sr-only, aria-live, alt text, hit area, touch target, prefers-reduced-motion, autoplay, toast duration, skip link, semantic HTML, aria-label, form errors, disabled buttons, "not keyboard accessible".

xzedm/clipplic-landing

OKLCH color space and color usage for web projects. Convert hex/rgb/hsl to oklch, generate palettes, check contrast, handle gamut boundaries, theme with Tailwind v4, and apply color with meaning. Triggers on oklch, color conversion, palette generation, contrast ratio, gamut, display p3, design tokens, semantic color tokens, hue drift, chroma, dark mode colors, accent color, color meaning, light and dark appearance, increased contrast.

xzedm/clipplic-landing

Layout structure for web interfaces, from grouping and alignment to reading order, progressive disclosure, and adaptive breakpoints. Use when structuring a page or component, spacing or aligning controls, deciding what collapses at small sizes, handling RTL layout direction, or reviewing frontend code for layout. Triggers on layout, spacing, alignment, grouping, negative space, whitespace, visual hierarchy, reading order, progressive disclosure, breakpoints, responsive layout, container queries, safe area, full-bleed, edge-to-edge, layout margins, RTL layout, logical properties.

xzedm/clipplic-landing

Web typography from choosing fonts to spacing, wrapping and accessibility. Use when picking or pairing typefaces, configuring variable fonts or OpenType features, setting up a type scale, checking heading hierarchy, styling text in components, truncating text, styling underlines, selection, placeholders or carets, or reviewing frontend code for typography. Triggers on typography, fonts, font formats, woff2, variable fonts, font-weight, opentype, font-feature-settings, letter-spacing, line-height, type scale, heading hierarchy, heading levels, tabular numbers, text-wrap, truncation, line clamp, underlines, text-decoration, text selection, iOS input zoom, scaled input text, font smoothing, text contrast, measure, line length, text-box, smart punctuation, drop cap.

xzedm/clipplic-landing

Design engineering principles for making interfaces feel polished. Use when building UI components, reviewing frontend code, implementing animations, hover states, shadows, borders, micro-interactions, enter/exit animations, choosing or reviewing icons, or any visual detail work. Triggers on UI polish, design details, "make it feel better", "feels off", stagger animations, border radius, optical alignment, image outlines, box shadows, icons, icon stroke weight, icon states, motion restraint.

xzedm/clipplic-landing

Deploy applications and websites to Vercel. Use when the user requests deployment actions like "deploy my app", "deploy and give me the link", "push this live", or "create a preview deployment".

xzedm/clipplic-landing

Generate developer handoff specs from a design. Use when a design is ready for engineering and needs a spec sheet covering layout, design tokens, component props, interaction states, responsive breakpoints, edge cases, and animation details.

xzedm/clipplic-landing

This skill encodes Emil Kowalski's philosophy on UI polish, component design, animation decisions, and the invisible details that make software feel great.

xzedm/clipplic-landing

Extract design primitives from a public website and generate starter token files for your project.

xzedm/clipplic-landing

Use this skill alongside figma-use when the task involves translating an application page, view, or multi-section layout into Figma. Triggers: 'write to Figma', 'create in Figma from code', 'push page to Figma', 'take this app/page and build it in Figma', 'create a screen', 'build a landing page in Figma', 'update the Figma screen to match code', 'convert this modal/dialog/drawer/panel to Figma'. This is the preferred workflow skill whenever the user wants to build or update a full page, modal, dialog, drawer, sidebar, panel, or any composed multi-section view in Figma from code or a description. Discovers design system components, variables, and styles from Code Connect files, existing screens, and library search, then imports them and assembles views incrementally section-by-section using design system tokens instead of hardcoded values.

xzedm/clipplic-landing

**MANDATORY prerequisite**: you MUST invoke this skill BEFORE every `use_figma` tool call. NEVER call `use_figma` directly without loading this skill first. Skipping it causes common, hard-to-debug failures. Trigger whenever the user wants to perform a write action or a unique read action that requires JavaScript execution in the Figma file context, e.g. create/edit/delete nodes, set up variables or tokens, build components and variants, modify auto-layout or fills, bind variables to properties, or inspect file structure programmatically.

xzedm/clipplic-landing

Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.

xzedm/clipplic-landing

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications.

xzedm/clipplic-landing

Elite UX/UI & Advanced GSAP Motion Engineer. Enforces Python-driven true randomization for layout variance, strict AIDA page structure, wide editorial typography (bans 6-line wraps), gapless bento grids, strict GSAP ScrollTriggers (pinning, stacking, scrubbing), inline micro-images, and massive section spacing.

xzedm/clipplic-landing

Fast headless browser for QA testing and site dogfooding. Navigate pages, interact with elements, verify state, diff before/after, take annotated screenshots, test responsive layouts, forms, uploads, dialogs, and capture bug evidence. Use when asked to open or test a site, verify a deployment, dogfood a user flow, or file a bug with screenshots. (gstack)

관련 스킬