Welcome to the log

This is the first entry in log.aszc.dev, a working notebook for Apple Silicon machine-learning engineering. It is also, on purpose, a reference page: nearly every layout component, shortcode, and metadata field the rest of this log will rely on appears at least once below. If something renders correctly here, it renders everywhere.

Why this log exists

aszc.dev is the front door — projects, links, the polished surface. This log is the workshop behind it: Core ML conversions, Apple Neural Engine benchmarks, diffusion-model timing, and the experiments that did not work. The format is deliberately small: short entries, real numbers, exact versions, no narrative padding. An honest failed run beats a clean story with no data behind it.

The stack

The whole site is static. There is no database, no CMS, and no client-side framework — by design.

• Hugo (extended) — static-site generation and templating.
• Org-mode + ox-hugo — .org files are the source of truth; Markdown under content/ is generated.
• Pagefind — fully static search, indexed after the build.
• Custom CSS — small, hand-written, no framework.
• Docker → nginx — the production image serves static files only.
• Coolify — deployment target.

The build pipeline is two commands and produces a directory of plain files:

hugo --minify              # render content/ -> public/
pagefind --site public     # index public/ for static search

A compact view of the flow:

The repository, for the curious:

(It is private for now.)

Tags, categories, and search

This log uses two taxonomies on purpose. Tags are specific and many — coreml, ane, apple-silicon — and drive the per-topic pages under /tags/. Categories are broad and few — experiments, notes, meta — and describe the kind of entry. Pagefind indexes the full text on top of both, so finding an old result is a search away rather than a scroll. Every post declares these in its front-matter, which in Org-mode lives in subtree properties.

Writing with an AI companion

The prose you are reading was drafted in a loop with an AI assistant. The division of labor is deliberate:

1. I set the thesis, the structure, and every number.
2. The assistant drafts and tightens — first passes, alternative phrasings, ruthless trimming of the boring middle.
3. I verify each claim and keep final say on tone.

The model is a fast, tireless editor with no ego about its own sentences. That is exactly what a draft needs — and exactly what a fact needs to be checked against.

Building with an AI companion

The same loop built the site. Scaffolding, layouts, the Dockerfile, this very component gallery — drafted with an assistant, then run and observed before being trusted. The rule is simple: nothing ships on the strength of “it looks right.”

A typical verification pass:

pnpm run build                              # full production build
python3 -m http.server -d public 8899       # serve the static output
curl -s localhost:8899/welcome/ | grep -i benchmark   # confirm it actually rendered

Component gallery

For reference, the remaining callout types this log uses:

A benchmark table via the benchmark shortcode — these are real figures from this site’s clean build:

Inline elements render as expected: inline code, bold, italic, and a link to the main site. Lists nest cleanly:

1. Author in Org-mode.
2. Export with ox-hugo:
   • one subtree per post,
   • tags and categories as properties,
   • custom front-matter for benchmark and reproduce data.
3. Commit the generated Markdown.

Footnotes work too.¹

A short sample in another language, to confirm syntax highlighting holds across the blog:

import coremltools as ct

model = ct.convert(
    traced_model,
    compute_units=ct.ComputeUnit.CPU_AND_NE,   # target the Neural Engine
    minimum_deployment_target=ct.target.macOS15,
)

Metadata panels

Two structured blocks bracket this post and are driven entirely by front-matter:

• The Benchmark panel (top) comes from the [benchmark] table. Only fields that exist are shown, so a post fills in as much or as little as it has — this one omits precision and compute unit, and they simply do not appear.
• The Reproduce panel (below) comes from the [reproduce] table: repo, commit, branch, command, environment, and hardware.

That is how every experiment entry will carry its context without cluttering the prose.

What’s next

Real entries: Core ML conversion notes, ANE timing, ComfyUI integration logs, and the occasional post-mortem. The feed and search are live now —

• subscribe via RSS,
• or search the log.

Welcome in.