SuperAPI AI Directory

hangul-font-studio

General & other

View repository

Updated 10-16 07:58

About this skill

Hangul Font Studio — Orchestrator

Goal: Produce an original Hangul font the world has never seen through a sample → feedback → improvement loop.

Team Composition (12 agents, definition: .claude/agents/)

Agent Role Primary Skill
font-director Creative director, approve/reject —
hangul-analyst Jamo·block·coverage analysis hangul-composition
concept-artist Concept discovery + sample glyphs hangul-composition, glyph-design
choseong-designer 19 initial consonants + variants glyph-design
jungseong-designer 21 medial vowels + variants glyph-design
jongseong-designer 27 final consonant types glyph-design
latin-symbol-designer Latin·numbers·symbols glyph-design
composition-engineer Slot table, syllable composition hangul-composition, glyph-design
specimen-designer Specimen production·distribution font-specimen
font-engineer TTF build font-build
type-qa Consistency·boundary verification glyph-design, font-build
feedback-analyst Feedback → change spec design-feedback

In every Agent call, specify model: "opus".

Phase 0: Context Check (required every run)

_workspace/ Determine the execution mode based on the status:

  1. _workspace/ None → Initial run: Full run from Phase 1
  2. _workspace/ Present + feedback/partial revision request → Partial rerun: Start from feedback-analyst and re-invoke only the agents specified by the change spec. First read the _workspace/feedback/·_workspace/decisions/ history. If it is a request to modify specific characters·jamo, go directly to the jamo revision loop (12) in Phase 3 — modify jamo definitions → regenerate → rebuild
  3. _workspace/ Present + completely new direction request → New run: Move the existing to _workspace_prev/and then initial run
  4. If it is ambiguous which one it is, confirm with the user — do not arbitrarily decide to overwrite existing work

Workflow

Phase 1: Concept Exploration — Execution mode: sub-agents (parallel)

Since this is independent exploration, team communication is unnecessary. To prevent contamination between concepts, they should rather not know about each other.

  1. Generate sample syllable set·jamo decomposition table with hangul-analyst (_workspace/analysis/)
  2. Spawn 2–4 concept-artists in parallel with briefs on different axes (structure/stroke/space) (run_in_background: true)
    • Each produces concept.md + sample glyph SVG in _workspace/concepts/{콘셉트명}/Produce concept.md + sample glyph SVG
  3. font-director evaluates the results (_workspace/decisions/round-1.md)

Phase 2: Specimen Production and Feedback — Execution mode: sub-agents (pipeline)

  1. type-qa verifies glyph conventions (no stroke, viewBox, etc. — mechanical detection first)
  2. specimen-designer가 _workspace/specimens/round-{N}.html production + Artifact distribution
  3. Await user feedback — receive answers to the question block in the specimen
  4. feedback-analyst converts feedback into a change spec (_workspace/feedback/round-{N}.md)
  5. Recall the responsible agent according to the changed spec → return to 5. Repeat this loop until the concept is finalized

Phase 3: Main production — Jamo combination system (after concept finalization) — Execution mode: Hybrid

Main production is not manual syllable work but Jamo definitions × combination engine(built in Round 4, see the "Jamo combination system" section of the hangul-composition skill). Cheonjiin system: _workspace/glyphs/천지인/system/ — owned by composition-engineer.

  1. System construction/extension (if new concept): composition-engineer verifies the context box (contexts.json) and engine — visual comparison between handcrafted samples and engine-regenerated output is the acceptance criterion
  2. Write Jamo definitions (sub-parallel): choseong/jungseong/jongseong-designer each handle jamo_cho/jung/jong.json — files are separate so there is no conflict. Each generates test syllables with compose.py → renders a contact sheet → submits after passing the Read-based inspection loop
  3. Full generation + sample QA: compose.py --ks2350to generate 11,172 characters → visual verification of samples including everyday words + extreme combinations (double consonants, compound vowels, double final consonants)
  4. Jamo revision loop (when there is feedback/QA criticism): do not fix individual SVGs, but fix the cause in the Jamo definition → regenerate everything → re-verify samples. Reason: individual fixes are lost on regeneration, whereas a Jamo fix applies uniformly to all characters that use that Jamo
  5. Update the draft (the 5–8 loop of Phase 2) — do not increase coverage without feedback

Phase 4: Build·release — Execution mode: Sub-agent

  1. Produce Latin and symbols appearing in the draft with latin-symbol-designer (when requested)
  2. font-engineer builds the TTF — --family는 ASCII("Cheonjiin") + --family-ko "천지인" (font-build skill: non-ASCII default names are rejected on macOS installation) + build report
  3. type-qa verifies the build artifact boundaries (manifest ↔ TTF glyph count·cmap cross-check) + confirms actual typesetting rendering with PIL
  4. When release is requested: the release procedure of the font-build skill — fonts/keep only the latest version, update the README version table, push with a Korean commit message (github.com/revfactory/font-harness)

Data transfer protocol

  • File-based (primary): all artifacts are stored at _workspace/ convention paths. Filenames and paths are the interface
  • Team mode: TaskCreate (tasks·dependencies) + SendMessage (real-time coordination such as interface coordinates and rejection reasons)
  • Sub mode: return values (summary·warnings) + files (artifacts)
_workspace/
├── analysis/        # hangul-analyst: 음절 분해, 커버리지, 제작 브리프
├── concepts/{명}/   # concept.md + glyphs/*.svg + manifest.json
├── glyphs/{명}/
│   ├── syllables/   # 손 제작 음절 (초기 라운드 검증용)
│   ├── system/      # 자모 조합 시스템: jamo_*.json + contexts.json + compose.py
│   └── generated/   # 엔진 생성 전체 음절 + manifest.json (재생성 가능 — 수정 금지)
├── specimens/       # round-{NN}.html (+ round-{N}-copy.json)
├── feedback/        # round-{N}.md
├── decisions/       # font-director 결정 기록
├── qa/              # 검수 리포트
└── build/           # TTF (버전별 보존)
fonts/               # 배포 폴더 — 최신 릴리스 1개만 (README·GitHub 공개용)

Error handling

Situation Handling
Agent artifact missing/convention violation Retry once (specifying the violation) → if it fails again, proceed excluding that item and state the omission in the draft·report
1 failure during parallel concept exploration Proceed with the rest, record the failed concept in the decision document
Slot/spec conflict (contradiction between designers) Do not delete; list both → font-director arbitration, record decision
Build-failing glyph Exclude from build + state in report, fix as top priority next round
Ambiguous feedback interpretation Do not proceed arbitrarily; ask the user with the minimum number of clarifying questions

Test scenarios

Normal flow (initial run): "Make an original Korean font sample" → Phase 0 (initial assessment) → analysis → 3 concepts in parallel → QA → distribute draft round-01 → present feedback questions. Success criteria: _workspace/concepts/ 2 or more, draft contains type labels, explicit omissions, and a question block.

Error flow (partial rerun + artifact defect): "The final consonant is too big, fix it" → Phase 0 (partial rerun assessment) → feedback-analyst generalizes to "adjust type 4·5·6 final-consonant slots" → re-invoke composition-engineer → during recomposition, discover a ㅄ glyph convention violation → return once and retry → on failure, update the draft with a placeholder for that syllable + state the omission. Success criteria: fix by rule unit rather than only the pointed-out character, and the omission is marked in the draft.