arla6ka/design.how

make-font

Use when someone wants their own font made from fonts they like, such as "make me a font like these", "/make-font" or "build a typeface from these screenshots".

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/arla6ka/design.how --skill make-font

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

Make a font

The person names fonts they like. This skill measures them, picks an open-licence (OFL or Apache) font as the base, and bends that base to the measured numbers. Every outline in the result comes from the open base. The references give numbers only: proportions, stem and stroke thickness, class-mean widths and spacing. The output ships under the OFL with a new family name.

The line it holds

Say this to the person at the start, in plain words: "I match proportions, widths and spacing on an open font. I don't trace or copy the outlines of the fonts you send." Then hold it.

  • Never open a reference font in the build step. fit_font.py and space_font.py read only the base font and

targets.json.

  • Never take a per-glyph advance, a kerning pair or a point from a reference. Targets are font-wide numbers and

class means.

  • Refuse a request to clone, trace, convert or "rebuild exactly" a commercial font, or to rename one. Offer the

proportional match instead.

  • A screenshot of a commercial font is fine to measure. Its file is fine to measure if the person has it. Neither

is copied into the output or committed anywhere.

Scripts are in scripts/. They need Python 3.9+ with fonttools, brotli, uharfbuzz, numpy and pillow (skia-pathops to remove overlaps, fontbakery for its checks if wanted), and Node 18+ with Playwright for the PDF. Run Python as python3 -I and pass paths: every script reads --help. Downloaded fonts go in their own folder and are only read, never run.

Steps

  1. Ask once. In one message ask for: the fonts they like, as font files or screenshots (two to four is

plenty), what the font is for (text, display or UI), which scripts and languages it must cover, which weights, and a new family name. If they can type in the font (a foundry's type tester, a design tool), ask them to screenshot the four lines of SAMPLE_LINES in scripts/fontlib.py, large, cap height 80 px or more. Take defaults for anything unanswered and say which: text, Latin, Regular and Medium, a name you propose. Done when the references, use, scripts, weights and name are written down.

  1. Measure. Files: measure_font.py <file> --out m1.json. Screenshots:

measure_image.py <shot.png> --text "line|line" --out m2.json. Before trusting a screenshot, run measure_image.py --selftest <any open font> --px <its px per em> at the screenshot's size: it prints how far pixel readings land from the file's numbers. Report every number marked low confidence. Method, definitions and error sizes: references/measuring.md. Done when each reference has a measurement file and the person has seen the main numbers.

  1. Targets. `make_targets.py m1.json m2.json --family "New Name" --use text --scripts latin

--style Regular:400 --style Medium:500 --out targets.json. Where references disagree, the script lists the spread. Ask which way to lean instead of averaging a serif with a sans. Done when targets.json` exists and every spread has an answer or a stated default.

  1. Find the foundation. find_foundation.py targets.json --cache <dir> --out shortlist.json. It ranks open

families from the Google Fonts catalogue by distance to the targets, with variable fonts ahead (references/foundation.md). Show the person the top three to five with their deltas and axes, render each beside a reference if you can, recommend one, and wait for a yes. Note any Reserved Font Name. Done when the person confirmed a base. Do not build before that.

  1. Fit. fit_font.py <base-vf.ttf> targets.json --out-dir build/ [--loc opsz=..]. It solves a y instance for

stems and contrast, an x instance per width class for widths, merges them into one static per weight, and iterates until every class mean is within 0.3 percent, never stretching more than 3 percent (references/fitting.md). If a class hits the stretch limit, tell the person what that letter class will be and offer a base with a width axis. Done when every style is written and fit-log.json shows each class within tolerance or explained.

  1. Space. space_font.py build/X-Regular.fit.ttf targets.json --out build/X-Regular.ttf [--track -4].

Class sidebearings to the targets, an optional global track, kerning carried and scaled, then the collision guard (references/spacing.md). More than 150 guard pairs means the spacing is too tight. Loosen and rerun. Done when the guard count is under 150 and its log is saved.

  1. Package and check. `package.py build/*.ttf --targets targets.json --base <vf> --base-licence <OFL.txt>

--holder "<who owns the modifications>" --out-dir dist/ --fit-log build/fit-log.json --space-log ... (references/licensing.md), then check_font.py dist/ttf/*.ttf --targets targets.json --base <vf> --reference <ref file> --package dist/ --fit-log build/fit-log.json --out-dir checks/ (references/checks.md`). Look at every overlay render yourself, at the text and the display size. A failed gate goes back to the step that owns it. Done when the check exits 0, or each failure is listed for the person with its number and the reason.

  1. Font book. `font_book.py dist/ttf/*.ttf --webfonts dist/webfonts --targets targets.json --fit-log ...

--space-log ... --check-report checks/check-report.json --out-dir book/, then node scripts/renderbook.mjs book/`. It prints the pages as PNG and one PDF and fails on a fallback glyph or an overflow (`references/font-book.md`). Open three pages and look before you hand it over. Done when `book/fontbook.pdf` exists and renderbook.mjs exits 0.

Hand-off

Tell the person, in this order: what was made (family, weights, glyph count, scripts), the base and its licence, the gates with their numbers (pass and fail), what still differs from the references and why (the base's own drawing: terminals, serif shape, a letter that reads differently), and where the files are. Attach or link the PDF. Name the fonts' provenance plainly: built on an open font, fitted to measurements.

Never

  • Copy, trace, auto-trace or convert outlines from a reference. Copy a reference's kerning or per-glyph widths.
  • Ship under any licence but the OFL, keep the base's name or a Reserved Font Name, or keep its trademark record.
  • Put a reference font's name in the output files, the font book or the package README.
  • Call a gate passed that was not run in this session. fontbakery not installed is "not run", not "passed".
  • Stretch a glyph more than the limit to hit a number. Report the gap instead.
  • Commit or publish font files unless the person asks, and never a reference font.

Files

  • scripts/fontlib.py shared geometry, classes, sample lines, rasteriser.
  • scripts/measure_font.py, measure_image.py, make_targets.py: steps 2 and 3.
  • scripts/find_foundation.py: step 4. fit_font.py: step 5. space_font.py: step 6.
  • scripts/package.py, check_font.py: step 7. font_book.py, book.css, render_book.mjs: step 8.
  • references/: measuring, foundation, fitting, spacing, checks, licensing, font-book.
같은 저장소의 Skills

더 많은 Skills

모든 Skills
arla6ka
커뮤니티

build-design-system

Use when someone wants a design system built from the UI an app already ships, or one phase of it, such as "extract tokens from the app", "add states to our Button", "replace the hardcoded colors with tokens" or "start a design system". Moving screens onto an existing system's components is migrate-design-system. A vague whole-app ask goes to design-system-boss.

1시간 설치 수
2
GitHub Stars
549
업데이트
11월 18일
arla6ka
커뮤니티

component-docs

Use to write one component's documentation entry from its code, stories and real call sites, such as "document the button", "write docs for Select", "what states does Toast have", or usage rules for a new or changed component. Not for foundations or pages that span components, which no skill here writes, nor for changing the component, which is build-design-system.

1시간 설치 수
2
GitHub Stars
549
업데이트
11월 18일
arla6ka
커뮤니티

migrate-design-system

Use when an app has to move onto a design system that already exists, such as "migrate the app to our design system", "move every screen onto the new components", a rollout, or an adoption audit. Not for making the system or for swapping raw values for tokens, which are build-design-system.

1시간 설치 수
2
GitHub Stars
549
업데이트
11월 18일
arla6ka
커뮤니티

token-mapping

Use to report how hardcoded style values on a page, file or diff map onto a project's existing design tokens, such as "are we using our tokens here", "which hardcoded colors map to which tokens", a token audit or planning a token migration. It never edits. Replacing the values is build-design-system.

1시간 설치 수
2
GitHub Stars
549
업데이트
11월 18일