The Future is Agentic (Prairie Dev Con 2026 Takeaways)

With Prairie Dev Con (PrDC) 2026 complete, there was a clear theme in everything I managed to see and share—the future of software development is agentic. This doesn't necessarily mean it's all "doom and gloom," but rather an evolution has taken hold in our industry.

Three Perspectives on AI: My first conference panel

I am always grateful to Prairie Dev Con for accepting my wild ideas for talks and whatnot and allowing me the privilege of speaking to a fantastic audience. This year, I proposed something different—something unfamiliar to me.

I proposed a panel.

The Hypothesis

Why a panel? you ask? Good question.

If I am being honest, there are two reasons:

1. I wanted to try something different from a lecture-style conference submission.
2. I wanted to compare and contrast different viewpoints on the spot, rather than compile the data myself and share it.

The hypothesis was that different perspectives will focus on different areas when it comes to AI, specifically with large language models (LLMs).

With that hypothesis, I found three different people who I have discussed AI with previously and brought them together. We had an enterprise CIO, an investor, and a small business founder.

And then came the panel.

The Result

I asked a series of questions, and each of them presented their own take on the subject, and the answers were very interesting in my humble and likely biased opinion (considering it was my panel). Some answers landed almost exactly the same and just complemented each other, while others focused on the pressing concerns from their unique space.

What was most interesting was when they all landed on or near the same answer—considering such different experiences and different problems they are trying to solve. It was really fascinating.

You can check out the slides in the talks section of the website. One of my panelists did manage to record the session, but it is going to take some audio cleanup, so I'll see what I can do and hopefully share that if I can make it usable.

Takeaway 1: Agents aren't the future, they are the standard.

I have been working with LLM-flavoured AI for quite some time. Even though I was very sure agentic workloads were coming, what PrDC made me realize is that not only are they here—but they are standard when it comes to software development.

A large majority of the sessions this year were flavoured with AI, including (but definitely not limited to):

• Generation Is Cheap. Judgment Isn't. (This was the keynote)
• How product engineers at Microsoft are using AI
• Agent Skills, Plugins & Marketplaces
• Building AI-Powered Business Intelligence: Transform Your Data Warehouse into an Intelligent Decision
• Agentic AI Raises the Stakes for API Security
• Build an MCP Data Source
• AI Enablement in the SDLC: A Strategy Sampler for 2026
• The Tokens are Coming From Inside the House
• Securing the Software your Agent Wrote
• Getting the Most Out of AI Coding Agents: Lessons From a Year in the Trenches

The list continues but it is clear that AI and agents are the future based on these developers, one way or another. But it wasn't their words that really caught my interest, but the demonstrations and stories of "how" they are using agents today.

Agents are the New Keyboard for Code

I don't really know how else to put it, but from the demonstrations I saw, senior engineers were using coding agents as a replacement for their keyboards. So, rather than typing the code in themselves, they were getting the agents to write the code and then reviewing it.

This has made the new bottleneck the review process, which we see in open source projects ultimately reflecting what I saw at the conference.

But isn't that a bad thing?

I don't think so, no.

Although the software developers and senior folks were using agents as their primary way to change code, they were still actively using their skills to review and assess those changes. They were just doing multiple changes in parallel and reviewing them when they were ready.

It is still software development, but just in an accelerated form, not bound by hands at a keyboard.

Takeaway 2: It is Still Changing

Although it seems clear to me that agentic work is inevitable in software development, the future isn't written in stone. In fact, many developers dropped a line akin to "it will probably be different within the next 6–12 months."

That is wild.

The pace at which the way we code is changing, only to be accepted by thought leaders working (not owning) the space, is incredible.

When some new tech or standard would come along, it would take a year or two before people would really start adopting it en masse. But with agents? We literally don't use our code editors the same way anymore, and we know it is going to change more.

Conclusion

I love Prairie Dev Con, and this was no different.

I am grateful to have been selected, and also grateful to have been able to learn so much from so many experienced people.

In the end, I learned that LLMs and AI aren't just an evolution—but a revolution in how software engineering will work. The question is, will I (and you) be able to keep up?