PWV Portfolio Feed

We call the missing piece "coding taste"

It's the thousands of micro-decisions you've built up over years: how you name variables, when you extract helpers, which patterns you reach for, how you structure tests.

LLMs can't see any of it.

They optimize for the statistical avg.

//Take command of your code

Models
Claude frontier LLMs
Opus, Sonnet, Haiku

Taste
`taste-1` meta neuro-symbolics
Learns how you code

Extend
CLI, Skills, MCP
Build on top of it

Code
10x faster
Ship features fast


Review
2x quicker
Slash review time in half


Bugs
5x slashed
Catch issues early

most documentation landing pages fail the squint test

if i can't tell what your tool does in 3 seconds with my eyes half-closed, you already lost me

documentation that looks like a product gets read
documentation that looks like an afterthought gets skipped

Appreciate this a ton. Maintainers shouldn’t have to bankroll the tools and infra that the whole ecosystem depends on.

Glad Netlify could help fuel your OSS adventures. And yes to this: if your company relies on open source, sponsor a maintainer you use and help gear them up. ✌️

back in Berlin for a few days 🥰

- live and one-shot weather dashboard (Open-Meteo)

Type safety baseline:
`strict: true`, `noUncheckedIndexedAccess: true`, zero `any`.

If you build TUIs in TS and want composable primitives, try it:

$ pnpm add terminui
$ npm i terminui

Build something and share with me. :)

So you can swap in a Node backend, a test backend, or custom transport without changing widget code.

Examples include:
- primary-screen dashboard
- alternate-screen multi-frame simulation
- kitchen-sink demo (all widgets + constraints + styles)

Stateful renderers exist where they should (selection/offset state), while rendering stays pure.

Backend contract is deliberately tiny:
`size`, `draw`, `flush`, `clear`, cursor get/set + hide/show

- additive/subtractive modifier composition via `patchStyle`

This makes style composition functional and predictable.

Built-in widgets:
Block, Paragraph, List, Table, Gauge, LineGauge, Tabs, Sparkline, BarChart, Scrollbar, Clear

- resolve non-fill constraints first
- distribute remaining space by fill weights

Then leftover cells go to the last fill chunk for deterministic results.

Style system:
- named ANSI colors + indexed(0..255) + 24-bit RGB
- modifier bitflags (bold, italic, underline, etc)

`charWidth(codePoint)` detects width-2 glyphs, and writes a placeholder empty cell after them, which keeps cursor math, wrapping, and diffs stable across frames.

Layout uses a small constraint solver:
`Length`, `Percentage`, `Ratio`, `Min`, `Max`, `Fill`

`splitLayout` does two passes:

Diffs are structural (symbol + colors + modifiers), so unchanged cells never hit the draw path.

Wide-char correctness is built in (CJK/fullwidth).

3) draw only changed cells
4) flush
5) swap buffers
6) clear next write buffer

So terminal I/O scales with what changed, not with full screen size every frame.

Cell model is tiny but expressive:
- `symbol`
- `fg` / `bg` / optional `underlineColor`
- `modifier` bitmask

Core pipeline:
Backend -> Terminal -> Frame -> Buffer -> Cells

Widgets are pure render functions:
`(area: Rect, buf: Buffer) => void`

No classes, no `this`, no hidden mutable UI tree.

Frame loop is intentionally minimal:
1) render into current buffer
2) diff previous vs current (`bufferDiff`)

Introducing `terminui` 📟
A fast, double buffered toolkit for building terminal UIs.

I wanted a TUI toolkit with a small core model, predictable double buffered rendering (only changed cells flush), and strict types. 

Built with Command Code using my code and cli taste.

actually I think it'd work better as an anthology, like

*Deprecated: a collection of essays by software engineers about the existential crisis brought on by LLMs*