The Psychological Stakes of the AI Development Boom Software engineering is currently serving as the "canary in the AI coal mine." As Jeremy Howard, founder of Fast.ai, argued during his keynote at AI Engineer Melbourne, we are at a critical juncture where the work we choose to do with artificial intelligence will either amplify human flourishing or diminish the human spirit. Drawing on 50 years of psychological research, specifically **Self-Determination Theory (SDT)**, Howard highlighted that humans are naturally born to be curious, agentic, and inspired. However, this spirit can be crushed when individuals reject growth and responsibility, leading to the apathetic, listless state often observed in modern workplaces. The core of this tension lies in the difference between **eudaimonia**—fully actualizing one's capacities—and **hedonia**, the pursuit of frictionless, passive pleasure. While many AI tools are marketed on the promise of hedonia (making tasks easier, faster, and more automated), Howard warned that true satisfaction comes from the effortful mastery of a craft. When we outsource the cognitive heavy lifting to AI without maintaining a connection to the underlying principles, we risk losing the very autonomy and mastery that make us feel vital and self-motivated. Dark Flow and the Illusion of Productivity A particularly insidious phenomenon emerging in the AI era is what Howard terms **dark flow** or "junk flow." While traditional flow state occurs when a high level of challenge meets a high level of skill, dark flow mimics this sensation through a superficial, addictive feedback loop. It is the dopamine hit of seeing an agent generate 200 lines of code in seconds, regardless of whether that code is actually correct or understood by the developer. This "vibe coding" creates an **illusion of control** that can lead to massive technical debt—what Howard described as "200,000 lines of vibe-coded software" that becomes nearly impossible to debug or verify. Prominent developers like Armin Ronacher (creator of Flask) and George Hotz have begun to voice similar concerns. The thrill of rapid generation is often decoupled from external validation. Developers feel incredibly productive in the moment, but when faced with quarterly metrics or the need to ship reliable, high-accuracy products, they realize they have actually moved slower. The pace of meaningful progress declines as the time spent on verification and debugging failures increases, leading to a state of being busy without being effective. The Rise of Supervisory Engineering and Flow Decline Annie Vella of Westpac New Zealand expanded on these psychological costs through her longitudinal research on professional software engineers. She identified a new category of labor: **supervisory engineering**. This work involves directing AI, evaluating its outputs, and managing the "middle loop" of development. While 84% of engineers reported feeling more productive with AI, a growing number—nearly 27% within six months—reported a decline in their overall **Developer Experience (DX)**. Vella's findings suggest that **flow state** is the most negatively affected dimension of DX, followed by an increase in **cognitive load**. The frequent feedback loops provided by AI assistants act as constant interruptions, preventing engineers from entering the deep, focused states required for mastery. Furthermore, as tasks shift from creation to verification, the work begins to feel less like a craft and more like a clerical duty. Vella warned leaders that measuring productivity alone is insufficient; focusing strictly on output while ignoring the erosion of the craft will inevitably lead to **AI burnout**. Reclaiming the Craft through Augmentation Despite the risks of decay, both Howard and Vella emphasized that AI can be a powerful tool for **augmenting human intellect** rather than replacing it. This vision aligns with the historical missions of computing pioneers like Douglas Engelbart, who sought to organize intellectual capabilities into higher levels of synergistic structuring, and Kenneth Iverson, who viewed notation as a tool of thought. To achieve this, developers must intentionally use AI to support growth—using it to learn new foundational principles, experiment under demand, and tackle more complex tasks than they could alone. Howard demonstrated this approach through a tool called Solveit, designed to augment understanding. Rather than asking the AI to "do the work," the interaction focuses on clarifying complex papers, generating concrete examples for abstract concepts, and assisting in effortful debugging. The goal is to keep the human in the loop of craft, ensuring that every line of code or architectural decision is understood and verified by the person responsible. This requires a shift in mindset: moving away from the "done for you" marketing of AI platforms and toward a self-determined pursuit of mastery. Sovereignty and the Mesh Alternative to Hyperscalers While the psychological aspect of AI is critical, Mike Neil of Block addressed the physical constraints and power dynamics of the industry. Currently, AI development is heavily dependent on a few **hyperscalers** who own the massive compute resources required for large-scale models. This creates a crisis of **sovereignty**, where data and national interests are tied to fiber optic cables running to a handful of data centers in California. Neil pointed out the massive environmental impact of these centers, noting that the embodied energy in consumer devices—laptops and phones—often represents the majority of their lifetime energy consumption. Neil's proposed solution involves tapping into the vast, idle compute power already present in consumer devices. By creating a decentralized **mesh protocol**, we can move toward **zero marginal cost compute** and local model execution. This would not only reduce the climate impact of centralized data centers but also provide developers and nations with the optionality of where their models run. Sovereignty in the AI era isn't just about who writes the code, but who owns the hardware that executes it. Transitioning away from total dependence on hyperscalers is a necessary step for maintaining long-term autonomy in the software industry. Designing Your Own Future in the AI Era The future of software engineering likely splits into three paths: the **Artisanal Developer** (hand-coding for high-safety domains), the **Clerical Coder** (uncritically accepting AI PRs), and the **Orchestrator** (the code conductor building machines that build machines). The most significant predictor of success in this new landscape isn't seniority or company size, but **self-efficacy**—one's belief in their ability to accomplish tasks with these new tools. Unlike demographics, self-efficacy is a belief that can be changed through experimentation and mastery experiences. As the industry is "rebooted," every developer has become an explorer again. The challenge for both individual engineers and tech leaders is to design systems and workflows that prioritize **pride and joy** in the craft. We must resist the gravitational pull of "clerical coding" and dark flow, instead choosing pathways that encourage deep domain expertise and the construction of robust harnesses. By focusing on how work makes the person, rather than just the output the person makes, the software community can ensure that AI remains a tool for human flourishing rather than a source of professional diminishing.
Block
Companies
Jan 2026 • 1 videos
High activity month for Block. AI Engineer among the most active voices, with 1 videos across 1 sources.
Mar 2026 • 2 videos
High activity month for Block. The Prof G Pod – Scott Galloway among the most active voices, with 2 videos across 1 sources.
Apr 2026 • 1 videos
High activity month for Block. The Prof G Pod – Scott Galloway among the most active voices, with 1 videos across 1 sources.
May 2026 • 1 videos
High activity month for Block. 20VC with Harry Stebbings among the most active voices, with 1 videos across 1 sources.
Jun 2026 • 1 videos
High activity month for Block. AI Engineer among the most active voices, with 1 videos across 1 sources.
The Prof G Pod – Scott Galloway (3 mentions) drives the negative sentiment as it groups Block with companies that perform mass layoffs in "Brutal Quarter Ends With a Rally — But Risks Are Rising."
- Jun 4, 2026
- May 18, 2026
- Apr 1, 2026
- Mar 16, 2026
- Mar 13, 2026
Beyond the REST wrapper Software development is currently grappling with a fundamental misunderstanding of how artificial intelligence interacts with code. Jeremiah Lowin, founder and CEO of Prefect%20Technologies, argues that the industry is flooding the ecosystem with \"bad\" Model%20Context%20Protocol (MCP) servers. The core of the problem lies in the lazy habit of treating AI%20agents like human developers. Most creators simply point an MCP generator at an existing REST%20API and ship the resulting wrapper, assuming that if a human can use an endpoint, an AI can too. This assumption is not just wrong; it is architecturally damaging. Humans do not actually use APIs in their raw form; we build websites, mobile apps, and SDKs to shield ourselves from them. Agents, however, are forced to interface directly with these programmatic structures. When we give an agent a raw REST API, we are handing it a toolset designed for human strengths—one-time discovery and fast, cheap iteration—while ignoring the reality of agentic limitations. To build effective MCP servers, we must stop thinking in terms of infrastructure and start thinking in terms of product design. This means moving beyond the transport layer and focusing on the user interface of the future: the agentic interface. Three pillars of agentic interaction Designing for agents requires a fundamental shift in how we view discovery, iteration, and context. For a human developer, discovery is a one-time cost. You read the documentation once, understand the schema, and never look at the docs again for the life of that application. For an agent, discovery happens every single time it handshakes with a server. It must enumerate every tool and description, a process that is incredibly expensive in terms of token consumption and latency. Iteration follows a similar pattern of divergence. Human developers can run a script dozens of times a minute to debug a connection; it is fast and essentially free. For an agent, every additional call involves sending the entire history of previous calls back over the wire. Iteration is the enemy of performance. Finally, we must respect the limitations of context. While a human draws on years of memory and experience, even the most advanced Large%20Language%20Models (LLMs) operate with a limited \"brain\" of roughly 200,000 tokens. If your MCP server lobotomizes the agent on the initial handshake by consuming half its context window with documentation, the agent will fail before it even starts. The goal of a great MCP server is to find the needle in the haystack without forcing the agent to inspect every single piece of hay. Outcomes over atomic operations Engineers are traditionally trained to build atomic, granular operations. In a REST API, having separate endpoints for `get_user`, `get_orders`, and `filter_results` is considered a best practice. In an MCP server, this is a failure. Forcing an agent to act as a glue layer or an orchestrator is slow, expensive, and stochastic. Every round trip increases the chance of a hallucination or a timeout. Instead, we must design for outcomes. A single tool should map to a single agent story. Rather than providing three atomic tools that the agent must stitch together, provide one tool called `track_latest_order_by_email`. This buries the complexity of the API calls within the server-side logic, where it is fast and deterministic, and presents the agent with a clear path to success. This \"top-down\" workflow design ensures that the agent is not wasting its limited reasoning capabilities on basic plumbing that a human developer should have already handled. Argument flattening and schema discipline A recurring trap in MCP development is the use of complex, nested arguments. Developers often pass dictionaries or configuration objects, assuming the agent will intuit the structure. This often leads to \"doubly documented\" tools where the system prompt and the tool schema disagree, leaving the agent to guess which is correct. Lowin points out that many popular clients, including Claude%20Desktop, have historically struggled with structured object arguments, sometimes converting them to strings and breaking the handshake. The solution is radical simplicity: flatten your arguments. Use top-level primitives like strings, integers, and booleans. When choices are constrained, utilize literals or enums to provide a strict boundary for the agent. This reduces the cognitive load on the model and ensures that the arguments sent from the client match the expectations of the server. By naming arguments for the agent rather than the developer, you create an interface that is self-describing and resistant to the common pitfalls of LLM-based tool calling. The economy of the token budget The most overlooked constraint in MCP design is the token budget. Every character in a docstring, every field in a schema, and every example in a prompt costs tokens. Lowin highlights a cautionary tale of a company attempting to expose 800 endpoints via MCP. At that scale, the mere act of telling the agent what tools are available consumes the entire context window, leaving zero room for actual problem-solving. This is the \"handshake overflow,\" and it is the primary reason many enterprise-grade MCP servers feel sluggish or \"dumb.\" We must curate ruthlessly. A server with more than 50 tools is a red flag. If you find yourself exceeding this limit, it is time to namespace your tools or split the server into smaller, specialized units. One of the most effective ways to save tokens is to use \"progressive disclosure.\" Instead of documenting every edge case in the main tool description, use helpful error messages. In the agentic world, errors are prompts. If an agent calls a tool incorrectly, the server should return an error message that provides the necessary context to fix the call. This moves the token cost from the handshake (which happens every time) to the error recovery (which happens only when needed). Curation as the ultimate design goal The transition from infrastructure-thinking to product-thinking is the final hurdle for the MCP ecosystem. Tools like FastMCP have made it trivial to bootstrap a server by mirroring a REST API, but this should only ever be a starting point. The real work begins with curation. We must move toward \"context products\". These are highly optimized, specific interfaces that give an agent exactly what it needs to achieve a specific result, and nothing more. Treating an MCP server as a user interface changes the development lifecycle. It requires evaluation, testing against specific models, and an understanding of how different clients like Cursor or Claude%20Code handle the protocol. As the ecosystem matures, the focus will shift away from how we connect models to data and toward how we design the surface area of those connections. The developers who succeed will be those who view their servers not as a collection of functions, but as a carefully crafted experience for the most important new user in tech: the AI agent.
Jan 12, 2026