I shipped DevCard in early May. It's a CLI tool that generates developer identity cards from your GitHub profile. You run it, it pulls your repos, analyzes your contribution patterns across 14 different extractors, and generates a card with one of 5 visual themes. It scores you on two axes: human visibility (stars, followers, popular repos) and agent readiness (how well your code works with AI tooling). Shipped it on PyPI with an MCP server so AI agents can query developer profiles programmatically.
I was proud of the engineering. The dual-scoring model felt novel. The architecture was clean. I wrote a LinkedIn post announcing the launch.
// the vanity metrics hit
The post got around 50 likes. For my network size, that's solid. People left comments. "This is cool." "Interesting concept." "Love the idea." I felt good for about a day.
Then I checked the PyPI download counter.
Nearly zero.
Fifty people liked a post about a tool. Approximately none of them installed it. The gap between "this is interesting" and "I will open my terminal and type pip install" is apparently infinite.
// lesson 1: a post is not a distribution strategy
A thought leadership post on LinkedIn is engagement, not distribution. People scroll, they react, they move on. The cognitive jump from "I read a post about a cool tool" to "I will stop what I'm doing, open a terminal, install Python if I don't have it, run pip install, figure out the CLI flags, and generate a card" is enormous. I was asking for 5 minutes of setup effort from people who gave me 3 seconds of attention.
The post was optimized for likes, not for conversions. And I got exactly what I optimized for.
// lesson 2: demos beat descriptions
What I should have built first: a web app. Paste your GitHub username, get a card in 10 seconds. Zero friction. No install. No terminal. No pip. Just a URL you can share.
A CLI tool requires the user to already want the thing enough to go through setup friction. A web app creates want by showing you the result before you invest anything. The demo IS the distribution. Every person who generates a card shares it, and that share is the marketing.
I built the hard version first (full CLI with 14 extractors and 5 themes) when I should have built the easy version first (web form, one theme, instant result).
// lesson 3: the scoring model works
The one genuinely interesting finding: Andrej Karpathy, one of the most visible people in AI, scored lower on "agent readiness" than many random developers with 50 followers. His repos are famous but they're not structured for programmatic consumption. No MCP servers, limited structured metadata, mostly educational code.
Meanwhile, developers nobody's heard of who publish well-documented APIs with structured outputs score high on agent readiness. The two axes are genuinely orthogonal. The dual-scoring model measures something real, and that's the actual insight worth building around.
// what's next
The plan now is a GitHub Action. You add it to your repo, it auto-renders a DevCard SVG into your README on every push. No install friction. Organic daily impressions from everyone who visits your GitHub profile. The card updates itself as your contributions change.
This inverts the distribution problem. Instead of asking people to go somewhere and do something, the card lives where developers already are. Every README view is an impression. Every fork carries the card with it.
The engineering was the easy part. Distribution is the hard part. Everyone says this. Nobody believes it until they ship something and watch the download counter stay at zero.