That moment crystallized something I’d been circling for months: every blockchain ecosystem faces the same strategic fork once the table stakes are built. Do you invest in making it easier for newcomers to start, or in making it possible for experts to finish? The answer feels obvious until you look at where the money goes.
The Table Stakes Are Done. Now What?
APIs, SDKs, block explorers, wallets, smart contract deployment tools: most maturing ecosystems have checked these boxes. The first wave of developer tooling is infrastructure, and infrastructure by definition reaches a point of sufficiency. You can deploy a contract, query the chain, and build a basic dApp, which means you’ve reached parity with every other ecosystem that has an RPC endpoint and a JavaScript library.
The strategic question shifts from whether to keep building tools to which developers you build them for next. That choice reveals what you believe about how ecosystems grow.
The Finger Painter Hypothesis
The intuition is seductive: lower the barrier to entry and more developers show up, more developers means more apps, more apps means more users, and more users means a thriving ecosystem. It’s a growth funnel, so naturally the top of the funnel is where you pour resources.
NEAR bet heavily on this thesis. They launched a JavaScript SDK in August 2022 so web developers could write smart contracts without learning Rust, introduced human-readable account names to strip away the cryptographic hostility of hex addresses, and built an onboarding experience that felt smoother than most chains. Developer counts grew roughly 4x, which sounds impressive in a slide deck, albeit the absolute numbers remained small and the ecosystem struggled to produce the breakout applications that would pull in the next wave of builders, or more critically, users.
Cosmos took a similar bet with Ignite CLI (formerly Starport), promising developers they could scaffold an entire blockchain in five minutes. The pitch was irresistible at hackathons: type a command, get a chain, start building. Some projects built with Ignite found real traction, Osmosis and Juno among them, but the scaffolding itself wasn’t the hard part. Building something people use on that chain is where developers needed help, and that’s a problem no CLI generator solves.
This is the finger painter trap: you can fill a room with people holding brushes, and the room looks busy, and the photos look great, but the walls stay empty.
The Picasso Hypothesis
Foundry launched in December 2021 with a philosophy that would make any growth marketer wince: built by Solidity developers, for Solidity developers. Rather than making Ethereum accessible to Python developers or JavaScript newcomers, it focused entirely on making experienced Solidity developers dramatically more productive with faster compilation, better testing primitives, and a workflow that matched how they thought about smart contract development. Foundry didn’t lower the floor. It raised the ceiling.
The result compounded in ways that beginner tools rarely do. Expert developers who shipped faster built better protocols; those protocols attracted users; those users attracted more developers who now had better infrastructure to build on. The flywheel spun because the initial investment targeted the people who could turn tools into products.
Experts build the abstractions that beginners eventually use. Invest in Picassos and you get tools for everyone; invest in finger painters and you get dashboards that look good in board meetings.
Anchor is the clearest case study. Before Anchor, building on Solana meant wrestling with raw Rust and the Solana Program Library, a combination that Andre Cronje captured in early 2020 when he wrote that building in DeFi “sucks,” cataloging the friction that drove experienced developers away from ecosystems that should have been keeping them. Anchor, built by Armani Ferrante and the Coral team, turned Solana from Rust-hell into productive DeFi infrastructure. It made Solana usable for the semi-experts who were one good framework away from building the next wave of DeFi protocols.
Those protocols are what eventually made Solana accessible. The abstractions experts built became the on-ramps for the next tier of developers, who didn’t need to understand the raw runtime because Anchor handled it. The Picasso painted something that finger painters could learn from.
What the Data Actually Says
The Electric Capital Developer Report, published in January 2023 covering 2022 data, contains a number every ecosystem strategist should internalize: 92% of developers stopped committing to open-source crypto repos within a year. The 8% who kept contributing, the full-time builders, wrote 76% of all commits across the ecosystem. Three-quarters of the code that moves crypto forward comes from the fraction of developers who stuck around, and pouring more newcomers into the top of the funnel doesn’t change its mesh size.
Alchemy’s Web3 Developer Report for Q4 2022 adds another dimension: during the FTX collapse, when sentiment was at its lowest, Alchemy University received over 100,000 applicants. People wanted to learn even as an entire exchange empire was collapsing around them, which means interest in building on crypto was never the bottleneck. The constraint was whether the ecosystem could turn that interest into sustained, productive building.
The Nomic Foundation (formerly Nomic Labs, the team behind Hardhat) published research in November 2020 that systematically cataloged Ethereum developer pain points. One finding stood out: even small quality-of-life improvements, like adding console.log support for Solidity, had outsized impact on developer retention. The developers who stayed weren’t asking for lower barriers to entry; they were asking for their existing tools to stop wasting their time. The improvements that mattered most respected their expertise rather than routing around it.
The Polkadot Warning and the NEAR Paradox
Polkadot is the necessary counterweight. The ecosystem peaked at roughly 2,400 monthly active developers and shed nearly half of them over the course of 2022. Substrate is powerful, the parachain architecture is technically sophisticated, and the technology itself is innovative. So why didn’t the Picasso thesis hold?
Building for experts and making things unnecessarily hard are very different failures. Polkadot’s documentation was fragmented across multiple sources, the tooling ecosystem was balkanized between competing approaches, and developers more than capable of building sophisticated applications couldn’t find a coherent path through the maze. The experts weren’t struggling with conceptual difficulty; they were struggling with organizational chaos, which is a tooling failure rather than evidence against the expert-first thesis.
NEAR presents the inverse paradox. The developer experience is friendly, onboarding is smooth, and the team invested heavily in making the ecosystem welcoming, yet the ecosystem remains thin on applications that draw meaningful user bases. The finger painters showed up, looked around, and found an empty gallery. Without the expert-built infrastructure, protocols, and applications that give an ecosystem gravity, a friendly on-ramp leads to a parking lot.
The Uncomfortable Answer
The ecosystem flywheel has a specific ignition sequence, and it doesn’t start with onboarding workshops. It starts with experts building applications that attract users, users creating demand that attracts more developers, and those developers finding an ecosystem mature enough to be productive in. Skip the first step and the flywheel never catches.
This means your highest-leverage devtool investment looks counterintuitive on a slide deck. Empowering one Armani Ferrante to build Anchor does more for ecosystem growth than onboarding a thousand developers who build tutorial projects and leave. One expert building the framework that enables a hundred semi-experts to build real applications is the growth engine, albeit one that doesn’t photograph well for quarterly reports.
The flywheel doesn’t start with onboarding. It starts with one expert building something worth onboarding into.
A dashboard showing 10,000 new developer signups and zero new applications with users measures vanity, not ecosystem growth. Optimizing for those numbers because they’re easier to measure is how you lose the strategic battle, because the ecosystem that invested in making its best developers 10x more productive already shipped the protocol those 10,000 signups will eventually migrate to.
Build for Picassos first. Fill the gallery with work worth studying, and the finger painters will find their way in with something real to learn from.