`sodofi/design-thinking-skills`: The repo that compiles design thinking for humans and agents

A static site, a skill bundle, and a CROPS framework live in one source tree, so the same design process can coach people and LLMs.

8 min read · sodofi/design-thinking-skills

A single manuscript sits at the center of a print workshop and feeds two different outputs. One side becomes a polished reading page, while the other becomes a compact machine bundle ready for reuse. It explains the repository's central trick: one source tree serves both humans and agents. — One source tree, two readers, two outputs. The repo's value is not the page alone, but the way the page can also become an agent-ready skill.

Key Takeaways

`sodofi/design-thinking-skills` treats design thinking as infrastructure, not as a document library.
CROPS turns open source, privacy, security, and censorship resistance into constraints the method has to satisfy.
`build-site.js` matters more than the pages because it splits one source tree into a human site and an agent bundle.
The repo sits between docs-as-code and skill packs, which makes it a template for shipping methods instead of just explanations.

The repo that teaches AI to do design thinking

Most repos package a process for people. This one packages a process for people and an LLM at the same time. The trick in sodofi/design-thinking-skills is that it does not stop at a static website. It also compiles the same source into site/SKILL.md, a machine-readable bundle that can be loaded as a design coach.

That changes the unit of value. The interesting output is not a page about design thinking. It is a reusable method that can be fetched, rewritten, and executed in an agent workflow. The repo behaves less like documentation and more like infrastructure for judgment.

Why this exists at all

The repo sits in the world of The Synthesis, an Ethereum Foundation hackathon focused on agentic infrastructure. That context matters. When wallets, protocols, and autonomous agents are involved, fuzzy UX advice is not enough.

SKILL.md frames the assistant as a Senior Product Designer and uses trigger phrases to decide when to activate the skill. That is a small detail with a large implication: the repository is not just teaching a method, it is teaching a model when to switch into method mode.

CROPS turns design into a constraint system

The repository's differentiator is CROPS: Censorship Resistance, Open Source, Privacy, Security. In most design notes, those are values. Here they are constraints that shape decisions. The question is not whether the interface feels elegant. It is whether the design still holds if you remove intermediaries, expose dependencies, or narrow the trust boundary.

That matters because crypto UX has a habit of disguising protocol risk as interface polish. CROPS pushes the review upstream, where a design choice can affect permissions, custody, and how much the user has to trust the stack.

A close view shows a designer's gauge and stencil hovering over a layered protocol sketch. Some paths pass cleanly through the cutouts while others are blocked, which explains how CROPS works like a test rather than a slogan. — CROPS is doing real work here. It is a gate that forces design choices to survive security and trust questions before they ship.

The repository works best when you read it as a compiler. One source tree goes through one build step and comes out as two tailored products.

How one source tree becomes two products

scripts/build-site.js is the transformer. It rewrites internal Markdown links, renders HTML for the site, and assembles a bundled site/SKILL.md for ingestion. That means a single source tree fans out into a human navigation surface and an agent-ready payload.

The .agents/skills/ui-ux-pro-max/data directory deepens that idea. The repo is not just content, it is structured design intelligence: CSV-backed tokens, reasoning data, and sync scripts that keep the bundle coherent. The result is closer to a compiler than a CMS.

process.md adapts the Stanford d.school five-phase model for crypto, while personas.md gives the agent concrete users to reason about. Those files are less like reading material and more like inputs to a method engine.

A stack of markdown pages enters a compact press and emerges as two different artifacts, a readable handbook and a tight mechanical bundle. It shows how the build step repackages the same source for a human site and an agent skill. — The build step is the pivot. It turns prose into product twice, once for a person and once for a model.

Why this is not just docs-as-code

Model	Primary audience	What it ships	What it optimizes for
Traditional design thinking content	Humans	Slides, workshops, articles	Reflection and shared language
Docs-as-code repo	Humans	Versioned pages and source docs	Maintainability and publishing
Generic AI skill pack	Agents	Prompt files and instructions	Fast activation
`design-thinking-skills`	Humans and agents	A site plus a bundled skill from the same tree	A reusable method with real constraints

The distinction matters because the build step changes what the repository is for. It is not preserving knowledge in a folder. It is turning a design process into something you can ship, load, and reuse without flattening it into generic advice.

That is why the repo feels bigger than its contents. The site explains the method, but the method is also packaged as infrastructure. The same source material can teach a person, brief an agent, and keep both aligned.

What this pattern changes

The larger signal here is practical. Teams do not just need better documentation or better prompts. They need methods that can move between humans and agents without losing their edge.

design-thinking-skills offers one answer: keep the source authoritative, treat build tooling as part of the product, and make the same method legible to both readers. If that sounds like a compiler, that is because it is.