Avi Press built his company around a language he loved. For 16 years, Haskell shaped how he thought about code. He advocated for it. He sat on the board of the Haskell Foundation. And for the last seven years, Scarf’s core systems ran on it.
Now that era has ended. Not with drama or a dramatic rewrite. But with a reluctant shift. New work at Scarf flows into Python servers deployed alongside the old ones. Requests route where they belong. Functionality moves piece by piece. The Haskell services still handle traffic. Yet the future points elsewhere. Avi Press detailed the decision in a post published today.
Scarf operates a package registry and distribution network. It tracks open source adoption and powers downloads for countless projects. Its backend once relied on Servant for APIs and Beam for PostgreSQL interactions. A high-performance gateway service sat on WAI, directly in the download path. Those components delivered on uptime promises and contractual SLAs. Reliability held. The type system caught real bugs before they reached production. Performance came without heroic effort.
But the hidden costs mounted. Compilation times dragged. The surrounding machinery demanded constant attention. Nix setups. Build caches. Complex developer environments. CI pipelines tuned to the language’s demands. The team knew the sharp edges. They lived with them. For a while, that balance worked.
Then large language models upended the equation. Press saw the change clearly. Errors once caught only at compile time or runtime now surface during code generation. Models produce working snippets in minutes. A 15-minute cold build suddenly dominates the loop. One human coder might tolerate the wait. Five agents exploring branches in parallel multiply the tax.
“If an LLM can produce a working implementation in a few minutes, but your compile step takes dramatically longer, then your language and build system have become a bottleneck in the development loop,” Press wrote. The metric that matters now is the full feedback cycle. Cold starts. Average cases. Changes that touch core dependencies. Caching helps in the best scenarios. It never feels perfect. The effort to maintain those caches becomes its own burden.
Scarf responded with a gradual migration. New API routes land in Python. A second server runs in parallel. Routing logic directs traffic. Shared concerns like authentication, database access, and models required fresh implementations. In the past that overhead would have stung. With today’s models, porting existing logic proved straightforward. The time saved from toolchain battles now funds more features and denser test suites. AI generates tests rapidly, though humans still review them for quality.
Productivity gains showed up in unexpected places. Bug fixes sometimes deploy before a customer call ends. One Slack message can trigger a hotfix. The team feels energized. Less time spent wrestling with builds means more focus on customer problems. So far, the loss of type safety hasn’t created visible regressions. Comprehensive tests appear to fill the gap.
Press doesn’t write as an outsider. He remains involved with the Haskell Foundation, though running Scarf limits his bandwidth. His critique carries weight because it comes from deep care. He watched Haskell succeed in production at Scarf. Reliability. Thoughtful domain modeling. High performance. Those strengths endured.
The ecosystem, however, lags. Discussions around AI in Haskell circles often emphasize restrictions and disclosure norms. Those matter. Yet the dominant tone, Press argues, resists rather than embraces agent-driven workflows. He calls for a different focus. Faster project bootstraps. Agent-friendly error messages. Documentation packed with realistic, copy-pasteable examples. Reduced cold build times. Training data that better represents industrial patterns.
Haskell sits in a strong position if it adapts. Its type system could guide models toward correct code more efficiently than dynamic alternatives. Agents generate volume quickly but hate being blocked. Fast feedback loops suit them perfectly. The language could thrive in this environment. But only with deliberate changes in priorities.
Community conversations on the Haskell Discourse reveal similar tensions. One thread titled “Anti-LLM Sentiment Considered Harmful” shows developers pushing back against resistance. Participants note that agents handle Haskell’s guardrails well once properly prompted. They bounce off the type checker and converge. Yet compile-time pain remains a frequent complaint. Efforts to improve observability and reduce build friction continue, but progress feels incremental. The discussion on the Haskell Discourse forum highlights these debates.
Elsewhere, experiments with agent-augmented Haskell produce encouraging results. Developers report that newer models generate higher-quality code in the language than earlier versions. Training improvements and the inherent structure of existing Haskell code appear to help. One practitioner described teaching Claude to work effectively within the language’s constraints. The purity and type safety that once slowed humans now provide verification rails that agents can exploit. Parsons Matt outlined his approach to agent-friendly Haskell in a March post.
Hacker News threads reacting to Press’s announcement echo the divide. Some engineers defend Haskell’s strengths in correctness and maintainability. Others point to the same toolchain frustrations. One ongoing discussion asks what languages teams choose when they leave Haskell and why. Answers range from Go and Rust for performance to Python and TypeScript for speed of iteration. The Scarf case stands out because the company didn’t abandon the language entirely. It kept production services running while shifting new development.
Scarf’s data on open source trends, which Press referenced but didn’t share in full, suggests modest growth for Haskell compared with languages riding the AI wave. Other ecosystems accelerate. Hiring pools expand. Tooling evolves to match agent workflows. Haskell’s growth appears flatter. The opportunity cost rises as AI multiplies individual output.
Press hopes the community treats this moment with urgency. Industrial users have complained about compile times and ecosystem friction for years. Those issues now clash directly with how teams want to work. New language features like dependent types excite researchers. Yet many production teams prioritize faster feedback and lower setup costs.
The migration at Scarf didn’t require a big bang. No massive rewrite. No downtime. The parallel-server approach minimized risk. It also forced the team to confront duplicated logic and operational glue. Those duplicated efforts paid off in flexibility. Python’s ecosystem, vast and battle-tested, lowered barriers further. Models navigate it with ease.
And the results speak. Faster shipping. More comprehensive testing. Energized engineers. Hotfixes measured in minutes. These aren’t abstract gains. They translate into quicker responses to customer needs and competitive pressure.
Yet Press’s tone carries regret. He still respects what Haskell delivered. The language made him a better programmer. It forced thoughtful design. Scarf’s gateway service proved its production worth. The decision wasn’t taken lightly.
His message lands at a pivotal time. The Haskell Symposium scheduled for later this year will discuss practical experience and future directions. Implementors workshops continue to refine the toolchain. The foundation seeks more funding to coordinate work. Whether those efforts can shift priorities toward agent ergonomics, build performance, and onboarding speed will determine if Haskell captures the AI wave or watches it pass.
Other voices in the functional programming space draw parallels. Some argue that cultural barriers hurt adoption, much as they did for Haskell. A detailed gist examining factors that “killed” Haskell warns that similar patterns could affect Rust if communities grow insular. Accessibility for newcomers and enterprise suitability matter more than raw technical brilliance. The analysis on GitHub explores those cultural dynamics.
Scarf’s move won’t end Haskell usage at the company. Existing services continue. Knowledge accumulated over years remains valuable. But the signal is clear. When development velocity becomes the dominant concern and AI changes the economics of iteration, certain tradeoffs no longer make sense.
The broader question now faces the entire Haskell community. Can it optimize for the world of cheap code generation and parallel agent exploration? Or will the focus stay on human-centric purity and academic advances? Press bets the former path offers the only realistic chance for growth. His company already placed its wager.
WebProNews is an iEntry Publication