Beyond Chat: MCP, AI SDKs & the Future of AI Workflows

Recently, I had the opportunity to speak at the AI & The Future of Work Masterclass (Kaduna Edition), where I gave a session focused on modern AI workflows, MCP servers, AI SDKs, and the growing shift from simple chatbots to AI systems that can interact with real tools and environments.

The talk explored how AI is evolving beyond text generation into something far more powerful: programmable systems capable of using tools, reading files, interacting with APIs, and automating workflows.

One of the major topics covered was the Model Context Protocol (MCP) and how it allows AI systems like Claude Desktop to connect to external tools through a standardized interface. I demonstrated how MCP servers work, how to connect them to AI clients, and how developers can build their own lightweight MCP servers to expose custom functionality to AI systems.

We also explored the growing open-source AI ecosystem, discussing tools and platforms that are making AI experimentation and development more accessible than ever.

Another important part of the session focused on modern AI SDKs, including the OpenAI SDK and Vercel AI SDK, and how they simplify the process of building AI-powered applications with features like streaming, tool calling, and multi-provider support.

Beyond the technical side, the session also touched on AI safety, responsible AI development, and concepts like prompt injection — highlighting why security, validation, and thoughtful system design are becoming increasingly important as AI gains access to more tools and workflows.

One of the key messages from the session was this:

AI is no longer just a chatbot.
It’s becoming a programmable layer for interacting with the digital world.

Huge thanks to the organizers and everyone who attended, engaged, and contributed to the conversations during the session.

Recently, I had the opportunity to speak at Kadict Hub on a topic titled “Simplicity & Scale”, where I explored how Vue.js balances simplicity, readability, and scalability in modern frontend development.

The session focused on how Vue’s design philosophy helps developers build applications that remain maintainable as they grow in complexity. I discussed concepts such as reactivity, Single File Components, reusable components, composables, and the Composition API, highlighting how these features contribute to a cleaner and more scalable developer experience.

I also touched on Vue’s ecosystem, including tools like Nuxt, Pinia, Vue Router, and VueUse, and how they help teams build production-ready applications efficiently.

One of the major themes of the talk was that simplicity is not the opposite of scale. In many ways, simplicity is what makes scale sustainable. Readable code, predictable architecture, and reusable patterns improve collaboration, onboarding, maintainability, and even how effectively AI tools can interact with modern codebases.

The session also included real-world insights from building production systems with Vue, including large multi-role applications and public-sector platforms.

Overall, the talk was an opportunity to introduce developers to Vue.js while sharing why its balance between flexibility, structure, and developer experience continues to make it one of the most enjoyable frameworks to work with.

At VueVerse Connect, I gave a talk titled “The Simplicity of Vue.js”, where I explored an idea that often gets overlooked in frontend discussions:

Simplicity is not just about learning faster, it’s about building systems that last longer.

In this session, I walked through how Vue’s design philosophy helps developers write code that is readable, maintainable, and scalable, even as applications grow in size and complexity. While Vue is often described as beginner-friendly, the goal of the talk was to show that its simplicity is actually one of its strongest architectural advantages in production environments.

The session covered how Single File Components (SFCs) make components easier to understand by keeping structure, logic, and intent together in one place. From there, I demonstrated how the Composition API and composables help teams organize logic by feature rather than by type, making large applications easier to reason about over time.

I also showed how props and reusable components allow teams to build consistent interfaces without duplication, and how patterns like provide/inject help manage complexity when applications scale beyond simple component hierarchies.

Beyond architecture, the talk connected simplicity to developer experience. Clean, readable code improves onboarding speed, reduces bugs, strengthens collaboration, and increasingly plays an important role in how effectively AI tools can assist developers working inside modern codebases.

To ground these ideas in practice, I referenced real-world experience building production systems where Vue supported complex workflows while remaining approachable and maintainable.

The core message of the session was simple:

Simplicity isn’t a limitation in frontend engineering.
It’s one of the most powerful tools we have for building software that scales.