The future of agentic services, tools, and data is coming.

Join the waitlist

APRIL 16 2025

Go, GraphQL, and MCP: A New Era For Developer Tools

A discussion about how Go, GraphQL, and Model Context Protocol (MCP) are revolutionizing developer workflows.

William Lyon
William Lyon
Developer Experience, Hypermode

In a recent Hypermode Live episode, Jens Neuse, co-founder and CEO of WunderGraph, shared insights into the evolving landscape of Go, GraphQL, and Model Context Protocol (MCP). This conversation highlighted how these technologies are reshaping developer workflows and enabling new possibilities in API management.

The journey from open source to enterprise solution

Jens began his journey in 2018 by creating GraphQL Go Tools, a library implementing GraphQL from lexers to ASTs, parsers, and everything needed to build dynamic GraphQL servers. What started as a simple proxy project to transform GraphQL requests evolved into a comprehensive solution for GraphQL federation.

"I never studied computer science," Jens shared. "I actually studied business psychology. But I found interest in building compilers and parsers and working with ASTs and transformation." This passion eventually led to founding WunderGraph, which recently raised a Series A round with investors including eBay.

GraphQL federation: Solving API complexity at scale

One of WunderGraph's core focuses is GraphQL Federation, which addresses a common problem in modern software development: API complexity at scale.

"Everybody's federating," Jens explained. "If you build an app, it is almost impossible that this app talks to one backend." Traditionally, organizations either have clients talking directly to multiple backends (client-side federation) or implement Backend-For-Frontend (BFF) architectures, both of which come with significant drawbacks.

GraphQL Federation provides a better solution: clients communicate with a single gateway (router) that interfaces with multiple backend services conforming to a federation specification. This approach offers several advantages:

  • A unified pattern for API management across the organization
  • Schema composition that prevents breaking changes
  • Clear visibility into which clients use which parts of the schema
  • Automatic detection of breaking changes during development

Why Go for high-performance developer tools

WunderGraph's core components, including its router, are built in Go. When asked why Go was chosen, Jens highlighted several key advantages:

  1. Simplicity and readability: "Go is a very productive language. With Go, nobody talks about the language. Everybody's just building high-performance things and solving problems."

  2. Performance: Go offers a sweet spot between development speed and runtime performance, making it ideal for building gateways and MCP servers.

  3. Excellent tooling: Performance profiling with pprof, concurrency with goroutines, and other Go tools make optimization straightforward.

  4. Readability in the AI era: As LLM-assisted coding becomes more prevalent, Go's simplicity makes it easier for developers to review and understand machine-generated code.

"In the future of software development, we as developers will be more like architects," Jens predicted. "We'll use LLMs to write a lot of code. We need to read this code. Go is simple to read and fast enough."

MCP: Transforming developer workflows

A significant portion of the conversation focused on Model Context Protocol (MCP), which is quickly becoming the standard for high-performance AI agent systems. Jens highlighted GitHub's recent release of their official MCP server written in Go, and the Go team's collaboration with Anthropic on an official Golang SDK for MCP.

Jens shared how WunderGraph is leveraging MCP to create what they call the "Dream Query" workflow:

"In GraphQL, a query is a document that describes what data we want. The Dream Query workflow doesn't start with the schema; it starts with the query."

Through MCP-enabled tools, WunderGraph allows developers to:

  1. Write a GraphQL query that might initially be invalid
  2. Ask an AI agent to make the query work
  3. Have the system automatically suggest schema changes, validate them, and provide a diff to implement

This entire process happens within the developer's IDE through a single prompt, significantly streamlining workflows that previously required manual searching and schema analysis.

The future of developer tools in the AI era

Jens offered thought-provoking insights on how AI will change developer tooling:

  1. The end of certain abstractions: "With LLMs, the time for ORMs is gone. We don't need that anymore. An LLM can introspect my database and generate the exact SQL query I need, along with the models to transform the data."

  2. New patterns for open source: "The new open source will not be open-sourcing the end result, the code, but open-sourcing the path. We can now open-source prompts."

  3. MCP as workflow enabler: Rather than simply exposing CLI commands through MCP, effective MCP servers need to be designed around developer workflows - "The CLI user is not the MCP user."

Conclusion

As Go, GraphQL, and MCP continue to evolve together, they're creating powerful new paradigms for developer productivity. WunderGraph's approach demonstrates how these technologies can be combined to solve complex API management challenges while enabling new AI-powered development workflows.

The conversation highlighted that we're in a transition period where developers are becoming more like architects, with tools like MCP helping to abstract away complexity and enable higher-level thinking about solutions rather than implementation details.

Resources

Be sure to subscribe to the Hypermode event calendar to keep up with future Hypermode Live events!

View all posts