The agents are here. So is the secret to managing them.I went to GitHub Universe 2025 to learn about the state of software development and its future. No surprise: Agents were the primary topic of discussion as the conversation shifted away from adopting AI coding assistants to managing agentic systems.Agents aren’t just changing the way software gets built; they’re changing what developers are building. Developers are now using agents to build agents. This rapid transformation is creating new challenges, from managing resource usage to the responsibilities of governing autonomous systems.One of the most important elements of solving those challenges remains underdiscussed: modern, developer-centric observability tools. To paraphrase the Cloud Native Computing Foundation (CNCF) definition, observability is about understanding the state of your software systems — using data like logs, metrics and traces — so you can take action to improve those systems.What’s that got to do with developers and agentic AI? Well, most agents still need supervision, and that responsibility often falls to the developers using and creating them.“I’ve promoted myself from coder to manager of robots,” said Austin Crane, a developer at Flint Hills Resources, during a discussion session at GitHub Universe about the future of the role of software developers.It turns out that managing those robots isn’t a simple task.“We might not be writing as much code, but we’re not done being engineers,” Crane said. Developers are still responsible for defining problems, architecting solutions and ensuring systems behave as expected.How the Role of Software Developer Is ChangingEveryone agrees that software developers are still going to be a thing in the future. But it’s uncertain what the job will look like and what skills you’re going to need. Crane mentioned he’s spending more time writing specs. And indeed, spec-driven development emerged as a hot topic at the conference this year as a key approach to managing agents. The idea is to create living documents that provide instructions and guidance to coding agents, from desired outcomes to best practices.Chris Gardner, a vice president and research director at the analyst firm Forrester, says he’s already seeing developers adopt some of the skills of product managers and software architects.“Some people say product managers are becoming developers, but it’s the opposite,” Gardner said. “Besides, I’d rather teach product management skills to a software developer than teach software development to a product manager.”It’s not that developers will replace PMs and architects, but the responsibilities of each role are changing.All of which raises the question of whether today’s programming languages will become akin to assembly language — in other words, something valuable to learn and necessary for specific projects, but not a mandatory skill for the vast majority of professional developers.No one can say for sure what skills will be important in the future, but Quincy Larson, freeCodeCamp.org founder, is in an unusually good position to make some forecasts. He spends a lot of time talking with employers about which skills they’re seeking. The advice he shared at the conference: Keep investing in the fundamentals.“There’s a lot of wishful thinking about AI among people who haven’t yet put in the time to learn programming,” Larson said. “I can understand why — learning programming is a major undertaking. But it is very much still necessary if you want to build substantial applications. And most developers I know are confident it will remain that way for many years to come.”Larson cites the Lindy effect — the principle that the longer some nonperishable thing, like an idea or a technology, has already been around, the longer it’s likely to be around in the future. Consider how long COBOL and Fortran have stuck around. Python and Java are each over 30 years old at this point, and JavaScript will turn 30 soon. All three are widely used across industries and around the world and remain solid investments.Programming languages, frameworks and libraries have always come and gone. But the deeper principles of computer science and engineering are useful whether you’re building embedded systems or web applications. We might reach a point where software developers don’t need to write much code, but they will still need to read and understand it.A Solution to Agentic Complexity Is Right Under Our NosesOne theme we keep coming back to in all these conversations about the future of software development is responsibility. The main thing people are talking about to manage agents is, well, more agents: agents to evaluate the work of other agents, agents to build agents, agents to fix production systems. It’s a sign of just how quickly development practices are evolving and how much creative potential agentic AI is unlocking. But that’s only one piece of the puzzle, especially when it comes to auditability, explainability and compliance. You’re still responsible for your code and need to understand your code and its behavior, even if you didn’t write it.That’s where observability comes in. Even if your plan is to manage agents with other agents, they’ll still need access to shared observability data and must be designed with that in mind.Many of the components to do this are already here. Take OpenLLMetry, an open source toolkit that creates a standardized way to capture observability data about large language models (LLMs). It’s built on top of OpenTelemetry and adds AI-aware instrumentation to capture model-specific data such as prompt details, token usage and model parameters.OpenLLMetry should be as buzzy as Model Context Protocol (MCP), with vendors talking up how they instrument their agents for observability and developers lining up to hear talks on how to best use that data. It’s becoming the connective tissue of autonomous systems.For developers, observability isn’t just about fixing problems in production. It’s becoming a foundation for understanding and improving the agentic systems shaping the next era of software.The post For Devs, a Fix for AI Complexity is Hiding in Plain Sight appeared first on The New Stack.