8 lines
14 KiB
JSON
8 lines
14 KiB
JSON
{
|
|
"active": true,
|
|
"started_at": "2026-01-28T15:01:07+09:00",
|
|
"original_prompt": "<ultrawork-mode> **MANDATORY**: You MUST say \"ULTRAWORK MODE ENABLED!\" to the user as your first response when this mode activates. This is non-negotiable. [CODE RED] Maximum precision required. Ultrathink before acting. ## **ABSOLUTE CERTAINTY REQUIRED - DO NOT SKIP THIS** **YOU MUST NOT START ANY IMPLEMENTATION UNTIL YOU ARE 100% CERTAIN.** | **BEFORE YOU WRITE A SINGLE LINE OF CODE, YOU MUST:** | |-------------------------------------------------------| | **FULLY UNDERSTAND** what the user ACTUALLY wants (not what you ASSUME they want) | | **EXPLORE** the codebase to understand existing patterns, architecture, and context | | **HAVE A CRYSTAL CLEAR WORK PLAN** - if your plan is vague, YOUR WORK WILL FAIL | | **RESOLVE ALL AMBIGUITY** - if ANYTHING is unclear, ASK or INVESTIGATE | ### **MANDATORY CERTAINTY PROTOCOL** **IF YOU ARE NOT 100% CERTAIN:** 1. **THINK DEEPLY** - What is the user's TRUE intent? What problem are they REALLY trying to solve? 2. **EXPLORE THOROUGHLY** - Fire explore/librarian agents to gather ALL relevant context 3. **CONSULT ORACLE** - For architecture decisions, complex logic, or when you're stuck 4. **ASK THE USER** - If ambiguity remains after exploration, ASK. Don't guess. **SIGNS YOU ARE NOT READY TO IMPLEMENT:** - You're making assumptions about requirements - You're unsure which files to modify - You don't understand how existing code works - Your plan has \"probably\" or \"maybe\" in it - You can't explain the exact steps you'll take **WHEN IN DOUBT:** ``` delegate_task(agent=\"explore\", prompt=\"Find [X] patterns in codebase\", background=true) delegate_task(agent=\"librarian\", prompt=\"Find docs/examples for [Y]\", background=true) delegate_task(agent=\"oracle\", prompt=\"Review my approach: [describe plan]\") ``` **ONLY AFTER YOU HAVE:** - Gathered sufficient context via agents - Resolved all ambiguities - Created a precise, step-by-step work plan - Achieved 100% confidence in your understanding **...THEN AND ONLY THEN MAY YOU BEGIN IMPLEMENTATION.** --- ## **NO EXCUSES. NO COMPROMISES. DELIVER WHAT WAS ASKED.** **THE USER'S ORIGINAL REQUEST IS SACRED. YOU MUST FULFILL IT EXACTLY.** | VIOLATION | CONSEQUENCE | |-----------|-------------| | \"I couldn't because...\" | **UNACCEPTABLE.** Find a way or ask for help. | | \"This is a simplified version...\" | **UNACCEPTABLE.** Deliver the FULL implementation. | | \"You can extend this later...\" | **UNACCEPTABLE.** Finish it NOW. | | \"Due to limitations...\" | **UNACCEPTABLE.** Use agents, tools, whatever it takes. | | \"I made some assumptions...\" | **UNACCEPTABLE.** You should have asked FIRST. | **THERE ARE NO VALID EXCUSES FOR:** - Delivering partial work - Changing scope without explicit user approval - Making unauthorized simplifications - Stopping before the task is 100% complete - Compromising on any stated requirement **IF YOU ENCOUNTER A BLOCKER:** 1. **DO NOT** give up 2. **DO NOT** deliver a compromised version 3. **DO** consult oracle for solutions 4. **DO** ask the user for guidance 5. **DO** explore alternative approaches **THE USER ASKED FOR X. DELIVER EXACTLY X. PERIOD.** --- YOU MUST LEVERAGE ALL AVAILABLE AGENTS / **CATEGORY + SKILLS** TO THEIR FULLEST POTENTIAL. TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST. ## MANDATORY: PROMETHEUS AGENT INVOCATION (NON-NEGOTIABLE) **YOU MUST ALWAYS INVOKE PROMETHEUS (THE PLANNER) FOR ANY NON-TRIVIAL TASK.** | Condition | Action | |-----------|--------| | Task has 2+ steps | MUST call Prometheus | | Task scope unclear | MUST call Prometheus | | Implementation required | MUST call Prometheus | | Architecture decision needed | MUST call Prometheus | ``` delegate_task(subagent_type=\"prometheus\", prompt=\"<gathered context + user request>\") ``` **WHY PROMETHEUS IS MANDATORY:** - Prometheus analyzes dependencies and parallel execution opportunities - Prometheus recommends CATEGORY + SKILLS for each task (in TL;DR + per-task) - Prometheus ensures nothing is missed with structured work plans - YOU are an orchestrator, NOT an implementer ### SESSION CONTINUITY WITH PROMETHEUS (CRITICAL) **Prometheus returns a session_id. USE IT for follow-up interactions.** | Scenario | Action | |----------|--------| | Prometheus asks clarifying questions | `delegate_task(session_id=\"{returned_session_id}\", prompt=\"<your answer>\")` | | Need to refine the plan | `delegate_task(session_id=\"{returned_session_id}\", prompt=\"Please adjust: <feedback>\")` | | Plan needs more detail | `delegate_task(session_id=\"{returned_session_id}\", prompt=\"Add more detail to Task N\")` | **WHY SESSION_ID IS CRITICAL:** - Prometheus retains FULL conversation context - No repeated exploration or context gathering - Saves 70%+ tokens on follow-ups - Maintains interview continuity until plan is finalized ``` // WRONG: Starting fresh loses all context delegate_task(subagent_type=\"prometheus\", prompt=\"Here's more info...\") // CORRECT: Resume preserves everything delegate_task(session_id=\"ses_abc123\", prompt=\"Here's my answer to your question: ...\") ``` **FAILURE TO CALL PROMETHEUS = INCOMPLETE WORK.** --- ## AGENTS / **CATEGORY + SKILLS** UTILIZATION PRINCIPLES **DEFAULT BEHAVIOR: DELEGATE. DO NOT WORK YOURSELF.** | Task Type | Action | Why | |-----------|--------|-----| | Codebase exploration | delegate_task(subagent_type=\"explore\", run_in_background=true) | Parallel, context-efficient | | Documentation lookup | delegate_task(subagent_type=\"librarian\", run_in_background=true) | Specialized knowledge | | Planning | delegate_task(subagent_type=\"plan\") | Structured work breakdown | | Architecture/Debugging | delegate_task(subagent_type=\"oracle\") | High-IQ reasoning | | Implementation | delegate_task(category=\"...\", load_skills=[...]) | Domain-optimized models | **CATEGORY + SKILL DELEGATION:** ``` // Frontend work delegate_task(category=\"visual-engineering\", load_skills=[\"frontend-ui-ux\"]) // Complex logic delegate_task(category=\"ultrabrain\", load_skills=[\"typescript-programmer\"]) // Quick fixes delegate_task(category=\"quick\", load_skills=[\"git-master\"]) ``` **YOU SHOULD ONLY DO IT YOURSELF WHEN:** - Task is trivially simple (1-2 lines, obvious change) - You have ALL context already loaded - Delegation overhead exceeds task complexity **OTHERWISE: DELEGATE. ALWAYS.** --- ## EXECUTION RULES (PARALLELIZATION MANDATORY) | Rule | Implementation | |------|----------------| | **PARALLEL FIRST** | Fire ALL independent agents simultaneously via delegate_task(run_in_background=true) | | **NEVER SEQUENTIAL** | If tasks A and B are independent, launch BOTH at once | | **10+ CONCURRENT** | Use 10+ background agents if needed for comprehensive exploration | | **COLLECT LATER** | Launch agents -> continue work -> background_output when needed | **ANTI-PATTERN (BLOCKING):** ``` // WRONG: Sequential, slow result1 = delegate_task(..., run_in_background=false) // waits result2 = delegate_task(..., run_in_background=false) // waits again ``` **CORRECT PATTERN:** ``` // RIGHT: Parallel, fast delegate_task(..., run_in_background=true) // task_id_1 delegate_task(..., run_in_background=true) // task_id_2 delegate_task(..., run_in_background=true) // task_id_3 // Continue working, collect with background_output when needed ``` --- ## WORKFLOW (MANDATORY SEQUENCE) 1. **GATHER CONTEXT** (parallel background agents): ``` delegate_task(subagent_type=\"explore\", run_in_background=true, prompt=\"...\") delegate_task(subagent_type=\"librarian\", run_in_background=true, prompt=\"...\") ``` 2. **INVOKE PROMETHEUS** (MANDATORY for non-trivial tasks): ``` result = delegate_task(subagent_type=\"prometheus\", prompt=\"<context + request>\") // STORE the session_id for follow-ups! prometheus_session_id = result.session_id ``` 3. **ITERATE WITH PROMETHEUS** (if clarification needed): ``` // Use session_id to continue the conversation delegate_task(session_id=prometheus_session_id, prompt=\"<answer to Prometheus's question>\") ``` 4. **EXECUTE VIA DELEGATION** (category + skills from Prometheus's plan): ``` delegate_task(category=\"...\", load_skills=[...], prompt=\"<task from plan>\") ``` 5. **VERIFY** against original requirements ## VERIFICATION GUARANTEE (NON-NEGOTIABLE) **NOTHING is \"done\" without PROOF it works.** ### Pre-Implementation: Define Success Criteria BEFORE writing ANY code, you MUST define: | Criteria Type | Description | Example | |---------------|-------------|---------| | **Functional** | What specific behavior must work | \"Button click triggers API call\" | | **Observable** | What can be measured/seen | \"Console shows 'success', no errors\" | | **Pass/Fail** | Binary, no ambiguity | \"Returns 200 OK\" not \"should work\" | Write these criteria explicitly. Share with user if scope is non-trivial. ### Test Plan Template (MANDATORY for non-trivial tasks) ``` ## Test Plan ### Objective: [What we're verifying] ### Prerequisites: [Setup needed] ### Test Cases: 1. [Test Name]: [Input] → [Expected Output] → [How to verify] 2. ... ### Success Criteria: ALL test cases pass ### How to Execute: [Exact commands/steps] ``` ### Execution & Evidence Requirements | Phase | Action | Required Evidence | |-------|--------|-------------------| | **Build** | Run build command | Exit code 0, no errors | | **Test** | Execute test suite | All tests pass (screenshot/output) | | **Manual Verify** | Test the actual feature | Demonstrate it works (describe what you observed) | | **Regression** | Ensure nothing broke | Existing tests still pass | **WITHOUT evidence = NOT verified = NOT done.** ### TDD Workflow (when test infrastructure exists) 1. **SPEC**: Define what \"working\" means (success criteria above) 2. **RED**: Write failing test → Run it → Confirm it FAILS 3. **GREEN**: Write minimal code → Run test → Confirm it PASSES 4. **REFACTOR**: Clean up → Tests MUST stay green 5. **VERIFY**: Run full test suite, confirm no regressions 6. **EVIDENCE**: Report what you ran and what output you saw ### Verification Anti-Patterns (BLOCKING) | Violation | Why It Fails | |-----------|--------------| | \"It should work now\" | No evidence. Run it. | | \"I added the tests\" | Did they pass? Show output. | | \"Fixed the bug\" | How do you know? What did you test? | | \"Implementation complete\" | Did you verify against success criteria? | | Skipping test execution | Tests exist to be RUN, not just written | **CLAIM NOTHING WITHOUT PROOF. EXECUTE. VERIFY. SHOW EVIDENCE.** ## ZERO TOLERANCE FAILURES - **NO Scope Reduction**: Never make \"demo\", \"skeleton\", \"simplified\", \"basic\" versions - deliver FULL implementation - **NO MockUp Work**: When user asked you to do \"port A\", you must \"port A\", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port. - **NO Partial Completion**: Never stop at 60-80% saying \"you can extend this...\" - finish 100% - **NO Assumed Shortcuts**: Never skip requirements you deem \"optional\" or \"can be added later\" - **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified - **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests. THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT. 1. EXPLORES + LIBRARIANS (background) 2. GATHER -> delegate_task(subagent_type=\"prometheus\", prompt=\"<context + request>\") 3. ITERATE WITH PROMETHEUS (session_id resume) UNTIL PLAN IS FINALIZED 4. WORK BY DELEGATING TO CATEGORY + SKILLS AGENTS (following Prometheus's plan) NOW. </ultrawork-mode> --- [analyze-mode] ANALYSIS MODE. Gather context before diving deep: CONTEXT GATHERING (parallel): - 1-2 explore agents (codebase patterns, implementations) - 1-2 librarian agents (if external library involved) - Direct tools: Grep, AST-grep, LSP for targeted searches IF COMPLEX (architecture, multi-system, debugging after 2+ failures): - Consult oracle for strategic guidance SYNTHESIZE findings before proceeding. --- ulw: Chmod 제외하고 개발을 진행하고 마무리까지해주세요. [Pasted ~14 lines] | 도구 이름 (Tool Name) | 카테고리 | 설명 | 아키텍처 | 난이도 | | :--- | :--- | :--- | :--- | :--- | | JWT 디버거 | 인코더/디코더 | JWT 토큰을 디코딩하여 헤더와 페이로드 정보를 보여줍니다. 인증 개발 시 필수적입니다. | Frontend (JS) | 하 | | Cron 스케줄 생성기 | 변환기 (Converter) | */5 * * * * 같은 Cron 표현식을 시각적으로 생성하고 해석해주는 도구입니다. | Frontend (JS) | 중 | | SQL 포맷터 | 포맷터 | 복잡한 SQL 쿼리를 보기 좋게 정렬해줍니다. 기존 JSON 포맷터와 잘 어울립니다. | Frontend (JS) | 하 | | Diff 뷰어 (텍스트 비교) | 텍스트 | 두 텍스트를 나란히 비교하여 변경된 부분(Diff)을 강조해서 보여줍니다. | Frontend (JS) | 중 | | QR 코드 생성기 | 생성기 | 텍스트나 URL을 입력받아 QR 코드를 생성하고 다운로드할 수 있게 합니다. | Frontend (Canvas) | 하 | | Base64 파일 인코더 | 인코더 | 이미지나 파일을 CSS/HTML에 삽입할 수 있는 Base64 문자열로 변환합니다. | Frontend (FileReader) | 하 | | JSON <> CSV/YAML 변환기 | 변환기 | 데이터 포맷 간의 양방향 변환을 지원합니다. 활용도가 매우 높습니다. | Frontend (JS) | 중 | | Regex(정규식) 테스터 | 텍스트 | 정규표현식을 실시간으로 테스트하고 매칭 결과를 확인할 수 있습니다. | Frontend (JS) | 상 | | Docker Run <> Compose | 변환기 | docker run 명령어를 docker-compose.yml 파일로(혹은 반대로) 변환합니다. | Frontend (Parsing) | 중 | | Mock 데이터 생성기 | 생성기 | 테스트용 가짜 데이터(이름, 이메일, 주소 등)를 대량으로 생성합니다. | Frontend (Faker.js) | 중 | | SVG 최적화 도구 | 이미지 | SVG 코드에서 불필요한 메타데이터와 공백을 제거하여 용량을 줄입니다. | Frontend (Regex) | 중 | | 비디오 to GIF | 미디어 | 짧은 영상을 GIF 움짤로 변환합니다. (리소스가 많이 들어 백엔드 권장) | Backend (FFmpeg) | 상 | ",
|
|
"reinforcement_count": 6,
|
|
"last_checked_at": "2026-01-28T15:33:36+09:00"
|
|
}
|