Wong Edan's
Cover
Artificial Intelligence

The Great AI Toolset Unification: No More “Koplo” Context Switching!

February 08, 2026 • By Azzar Budiyanto

Alright, kawan-kawan developer, gather ’round! Your resident tech provocateur, Wong Edan, is here, and today we’re diving headfirst into something that’s been making my brain do the ‘koplo’ dance of confusion: the current state of AI tools in our dev lives. Admit it, we’ve all been there. You’re knee-deep in VS Code, slinging some fantastic (or fantastically broken) code, and suddenly you need AI help. What do you do? You pop open your Cursor AI, or maybe a dedicated browser tab for Claude, ask your question, get your snippet, then copy-paste it back. Repeat this dance like a professional choreographer for hours. Productivity boost, my backside! It feels more like a productivity ‘shuffle’.

I mean, seriously, remember that Reddit thread from April 2024? Someone was grumbling about “having to open Cursor AI just to use the AI tools and then keep switching back to VS2022.” Bingo! That’s the pain point, my friends. We’re told AI is supposed to make us superhuman coders, yet we’re stuck playing digital hopscotch between applications. And let’s not forget the Big Bosses breathing down our necks, issuing edicts like, “Every engineer must use AI tools.” Great, but if the tools themselves are clunky, we’re just adding more friction, not reducing it.

But fear not, my edan (crazy) comrades! There’s a revolution brewing, a whisper in the tech winds, and it’s all about two unsung heroes: MCP and Skills. These aren’t just buzzwords; they’re the foundational pieces that will finally let our AI assistants stop being glorified text generators and start acting like proper digital colleagues, truly boosting our productivity usage without making us feel like we’re wrestling a headless chicken.

The AI Productivity Paradox: We Want Superpowers, Get Papercuts

Let’s be brutally honest. AI coding assistants like GitHub Copilot, Cursor AI, and others have been a godsend for many. They autocomplete, suggest refactors, write boilerplate faster than you can say “boilerplate,” and even debug simple issues. They provide that initial “boost in productivity when learning new CLI tools,” as someone on Hacker News mentioned regarding Claude Skills. It’s like having a hyper-efficient intern who knows a bazillion programming languages. Wonderful, right?

“Use these AI tools to help you do that more efficiently, but don’t forget the importance of your own coding skills and problem-solving abilities.”

— Builder.io, March 11, 2025

Absolutely, Builder.io, absolutely. Our own skills remain paramount. But here’s the paradox: while these tools are powerful, their power often feels caged. They live in their own little IDEs, or browser tabs, isolated from the messy, interconnected reality of our development workflows. They’re fantastic at generating code within their window, but what about:

  • Running tests?
  • Committing changes to Git?
  • Deploying a small fix?
  • Querying a live database for context?
  • Checking documentation from an external knowledge base?

Currently, that’s all us. The human developer. The one doing the context switching, the copy-pasting, the manual execution. We’re still the “glue code” for our AI. This isn’t just inefficient; it breaks our flow, drains our mental energy, and makes the “productivity boost” feel like a conditional statement with a heavy `else` clause: `if AI_works_in_sandbox then boost_productivity else user_suffers_context_switch_hell`. This, my friends, is why we need to talk about MCP.

MCP: The Universal Translator for AI Agents (No More ‘Lost in Translation’)

Imagine a world where your AI assistant isn’t just a smart text editor, but a genuine agent that can interact with any part of your development environment. A world where it can not only suggest a fix but apply it, test it, and commit it. Sounds like science fiction? Not anymore, thanks to MCP: the Meta-Coding Protocol.

What the heck is MCP? Simply put, it’s the glue. As Addy Osmani succinctly puts it: “If you’re using an an AI coding assistant like Cursor or Windsurf, MCP is the shared protocol that lets that assistant use external tools on your behalf.” Think of it as the common language, the API, the handshake protocol that allows AI assistants (and agentic AI in general) to communicate with the vast ecosystem of developer tools and services.

Why is MCP a Game-Changer?

Remember that Reddit user hating the switch between Cursor AI and VS2022? MCP is the answer to that prayer. Instead of being confined to its own environment, an MCP-enabled AI assistant can:

  • Execute shell commands: Need to `git status` or `npm install`? The AI can do it.
  • Interact with APIs: Query a database, call an internal service, update project management tickets.
  • Control IDE features: Open files, navigate to definitions, trigger refactoring tools directly within your primary IDE.
  • Access external information: Pull up-to-the-minute data or documentation from the web or internal knowledge bases. (As highlighted by the Google ADK and MCP collaboration findings, this is crucial for “AI-powered agents to perform useful, real-world tasks.”)

MCP isn’t just about reducing context switching; it’s about enabling true agency for AI. It moves AI from being a passive suggestion engine to an active participant in the development workflow. It’s like giving your AI an operating system and a set of universal drivers. Suddenly, it’s not just talking about your code; it’s interacting with your code, your environment, and your entire software supply chain.

How MCP Works (A Peek Under the Hood, for the Curious ‘Wong Edan’)

While the specifics of MCP are still evolving and might vary by implementation, the core idea is a standardized way for an AI agent to:

  1. Discover capabilities: “What tools are available in this environment? What can I do?”
  2. Call tools/functions: “Execute `git add .`” or “Call the `createPullRequest` API with these parameters.”
  3. Receive output: “The `git add .` command returned ‘No changes to commit’.”
  4. Manage context: Maintain a coherent understanding of the ongoing task across multiple tool interactions.

Think of it like a robust remote procedure call (RPC) mechanism, but specifically designed for AI agents to interact with a potentially heterogeneous collection of tools and services. It’s a protocol, not a single product. This means different AI tools (Cursor, Windsurf, Copilot, etc.) can theoretically use the same MCP to integrate with your existing IDE (VS Code, IntelliJ), your CI/CD pipeline (Jenkins, GitHub Actions), your cloud provider (AWS, GCP, Azure), and pretty much anything with an API or a CLI.

This “MCP integration into AI coding IDEs” is what LinkedIn was buzzing about, with folks exclaiming it has “totally changed my workflow and boost my productivity O” (LinkedIn, Feb 2025). It’s not just hype, it’s the foundation for the next leap in AI-assisted development.

Unleashing “Skills”: Giving AI Superpowers (Without the Cape)

Now, MCP provides the communication layer, the “how to talk.” But what does the AI say? What actions does it know how to take? That’s where Skills come in. If MCP is the network protocol, Skills are the applications, the specific functions, the specialized knowledge modules that an AI agent can invoke.

The concept isn’t entirely new. We’ve seen similar ideas with “plugins” for LLMs or the mention of “Claude Skills” on Hacker News, which talks about “skill files and extra tools in folders for the LLM to use.” Essentially, Skills are modular, specialized capabilities that augment the base intelligence of an LLM, allowing it to perform tasks beyond simple text generation or summarization.

What are Skills, Really?

Think of Skills as discrete, self-contained units of functionality that an AI agent can learn, invoke, and combine. They are often implemented as:

  • Function Calls: The LLM is trained or instructed to recognize when a specific external function or API call is needed and how to format its arguments.
  • Tool Wrappers: Small code snippets that wrap existing command-line tools or libraries, making them callable by the AI.
  • Specialized Prompts/Models: Mini-LLMs or carefully crafted prompts designed for a very specific task, e.g., “SQL Query Generation Skill.”

The beauty of Skills is their modularity. Instead of training one monolithic AI to do everything, you equip a general-purpose LLM with a library of specialized Skills. This means your AI agent can be incredibly versatile without being bloated.

Examples of Essential Skills for a Developer AI Agent:

  • GitManagementSkill:
    • cloneRepository(url)
    • commitChanges(message)
    • pushChanges()
    • createPullRequest(branch, title, description)
    • getDiff(file?)
  • CodeExecutionSkill:
    • runTests(filepath?)
    • executeCommand(command) (for custom scripts or CLI tools)
  • DatabaseQuerySkill:
    • executeQuery(sql)
    • getSchema(tableName?)
  • DocumentationSkill:
    • searchDocs(query) (e.g., in a Confluence or internal wiki)
    • summarizeArticle(url)
  • DeploymentSkill:
    • triggerBuild(pipelineId)
    • deployToEnvironment(environment, version)

    This is where things like the Replit agent shine, allowing you to “build apps using AI prompts and directly deploy to a production server within Replit in a single interface.” That’s a powerful deployment skill in action!

  • CommunicationSkill:
    • sendMessage(channel, message) (e.g., to Slack or Teams)
    • sendEmail(recipient, subject, body)

The implications are profound. With a rich library of Skills, an AI agent can move beyond just suggesting code; it can act on the suggestions, becoming an active participant in your workflow, capable of tackling multi-step, complex tasks.

The Power Couple: MCP + Skills = The Ultimate External AI Toolset

This is where the magic happens, folks. MCP provides the lingua franca and the communication channels, while Skills provide the discrete, actionable intelligence. Together, they form an “external AI toolset” that radically transforms how we interact with AI in development.

Imagine this scenario, fueled by MCP and an array of Skills:

You’re debugging a flaky microservice. You prompt your AI assistant (say, an advanced Cursor AI or a custom agent):
"Hey AI, this 'UserService' is intermittently failing with a 500 error on the `/users/{id}` endpoint. Can you investigate, fix it, and create a PR?"

Now, watch the AI agent (equipped with MCP and various Skills) go to work:

  1. Understanding the Request: The LLM parses your natural language prompt. It identifies the service, endpoint, error, and the desired actions (investigate, fix, PR).
  2. Investigation (MonitoringSkill + MCP):

    • AI invokes a MonitoringSkill to check recent logs for `UserService` failures (via MCP to Prometheus/Grafana API).
    • AI identifies specific error messages and stack traces.
    • AI then uses a DatabaseQuerySkill (via MCP to your database) to check if the error correlates with any data inconsistencies.
  3. Code Context (CodeNavigationSkill + MCP):

    • AI uses a CodeNavigationSkill to pinpoint the relevant code section for `/users/{id}` in `UserService` (via MCP to your IDE’s LSP).
    • It fetches surrounding code for context.
  4. Diagnosis & Fix (CodeGenerationSkill + MCP):

    • Based on logs, database checks, and code context, the AI identifies a potential null pointer dereference.
    • It invokes its CodeGenerationSkill to propose a fix, perhaps adding a null check or a default value.
    • AI uses MCP to apply this change directly to your open file in VS Code.
  5. Verification (TestingSkill + MCP):

    • AI then triggers its TestingSkill to run the relevant unit and integration tests (via MCP to your test runner, e.g., `npm test` or `mvn test`).
    • If tests pass, great! If not, it iterates, refines the fix, and re-tests.
  6. Version Control (GitManagementSkill + MCP):

    • Once confident, the AI uses its GitManagementSkill:
      • It stages the changes (`git add .` via MCP).
      • It commits with an appropriate message (`git commit -m “Fix: UserService null pointer on /users/{id}”` via MCP).
      • It creates a new branch (`git checkout -b fix/user-service-bug` via MCP).
      • It pushes the branch to the remote (`git push origin fix/user-service-bug` via MCP).
      • Finally, it creates a Pull Request on GitHub/GitLab with a detailed description (via MCP to the Git provider’s API).
  7. Notification (CommunicationSkill + MCP):

    • The AI then uses its CommunicationSkill to notify the relevant team channel on Slack that a PR has been created for the bug fix (via MCP to Slack API).

See? No more manual switching. No more copy-pasting. The AI handles the entire lifecycle, guided by your high-level prompt. This is the promise of “agentic AI” in action, as McKinsey talks about in “Seizing the agentic AI advantage.” It’s not just about AI generating code; it’s about AI orchestrating entire workflows.

The Benefits are Mind-Boggling (Even for a ‘Wong Edan’ like Me):

  • Unprecedented Productivity: Developers can focus on higher-level design and problem-solving, delegating the repetitive, multi-tool tasks to the AI. This is Microsoft’s vision for Copilot: “positioned to keep developers in charge, while increasing productivity.” (The Pragmatic Engineer, May 2025)
  • Seamless Workflow: Eliminate context switching entirely. Your IDE becomes the single pane of glass for human-AI collaboration.
  • Faster Iteration Cycles: Automated investigation, fix, test, and deployment means bugs are squashed faster, and features are shipped quicker.
  • Reduced Error Rates: AI agents can follow protocols perfectly, reducing human error in complex, multi-step operations.
  • Empowered AI: AI moves from being a passive assistant to an active, autonomous problem-solver within defined boundaries.

Real-World Impact and Use Cases: Beyond Just Coding

The implications of MCP and Skills extend far beyond just writing code. This unified external AI toolset can transform nearly every aspect of the software development lifecycle and beyond.

In the Dev Trenches:

  • Intelligent IDEs: Imagine VS Code, IntelliJ, or even Cursor AI, truly becoming “intelligent.” Not just generating code, but running static analysis, applying refactorings across a codebase, interacting with debuggers, and managing version control all through natural language prompts, thanks to MCP.
  • Automated Code Review & Quality: An AI agent with a “Code Review Skill” could proactively analyze pull requests for common patterns, security vulnerabilities, or style guide violations, then use a “Communication Skill” to post comments directly on the PR, or even suggest automated fixes.
  • Self-Healing CI/CD Pipelines: Pipelines could be equipped with “Monitoring Skills” and “Troubleshooting Skills.” If a build fails, the AI agent could automatically analyze logs, identify the root cause, propose a fix, and even attempt to auto-remediate simple issues, dramatically reducing MTTR (Mean Time To Recovery).
  • Smart Data Science & MLOps: Data scientists could prompt an AI to “Load the latest sales data, clean it, train a forecasting model, and deploy it as an API endpoint.” The AI, using skills to interact with data warehouses, ETL tools, machine learning frameworks, and deployment platforms, would orchestrate the entire workflow.
  • Project Management & Documentation: An AI agent could track ticket statuses, update project boards (Jira Skill), generate release notes from Git commits (Documentation Skill), or even draft technical specifications based on design discussions.

Beyond Code (Where the ‘Wong Edan’ Mind Truly Wanders):

  • Automated IT Support: Imagine an agent that can receive a user support ticket (“My VPN isn’t working”), use an “Identity Management Skill” to check user permissions, a “Network Diagnostic Skill” to check VPN server status, and a “Communication Skill” to guide the user through troubleshooting steps or escalate to a human if necessary.
  • Business Process Automation: Beyond RPA, agentic AI with skills could handle complex, conditional workflows across multiple enterprise systems, such as onboarding new employees (HR system skill, IT provisioning skill, communication skill).

This is where the vision of agentic AI truly materializes. It’s about AI not just as a tool, but as a competent, autonomous orchestrator of tasks across an interconnected digital world.

Challenges and the ‘Wong Edan’ Reality Check

Okay, okay, before we all start worshipping at the altar of MCP and Skills, let’s take a deep breath. My inner ‘Wong Edan’ demands a reality check. As powerful as this vision is, it comes with significant challenges. This ain’t no cakewalk, my friends.

1. Security, Security, Security (Like a ‘Guard Dog’ with Cyber Teeth)

Granting an AI agent the ability to execute commands, access databases, and deploy code via MCP is like handing the keys to your entire digital kingdom. A malicious prompt, a compromised AI model, or a poorly secured skill could have catastrophic consequences. We’re talking data breaches, production outages, and more. Strong authentication, authorization, sandboxing, and auditing mechanisms will be absolutely critical. The security implications of agentic AI with external tool access are immense and cannot be overstated.

2. Reliability and Predictability (No More ‘Hallucinations’ in Production)

LLMs, for all their brilliance, still “hallucinate.” What happens when an AI agent, given a chain of complex tasks, decides to hallucinate a command or misinterpret an output? An error in one step could cascade into chaos. Ensuring the reliability and predictability of AI agents, especially when they are interacting with real-world systems, is a monumental engineering challenge. We need robust error handling, rollback mechanisms, and transparent execution traces.

3. Complexity Management (Avoid the ‘Spaghetti Code’ of Skills)

As the number of Skills grows, managing them, ensuring compatibility, and debugging interactions between different skills will become a complex task. Who maintains these skills? How are they versioned? How do we prevent conflicts? This could quickly devolve into a “spaghetti code” situation, but for AI agents and their toolsets. A robust skill management framework and clear standards will be essential.

4. Trust and Oversight (The Developer Remains ‘Boss’)

Developers need to trust that the AI is doing what it’s told, and doing it correctly. This means mechanisms for human oversight, verification, and intervention are non-negotiable. As Builder.io wisely noted, our “own coding skills and problem-solving abilities” remain vital. We’re not automating ourselves out of a job; we’re just shifting our focus to higher-level challenges and AI supervision. The AI is the co-pilot, not the autonomous pilot without human intervention.

5. Vendor Lock-in vs. Open Standards (The ‘Balkanization’ of Protocols)

MCP is envisioned as a shared protocol. But in the real world, big tech companies love their ecosystems. Will MCP truly become an open, universally adopted standard, or will we see fragmented versions – a “Microsoft MCP,” a “Google MCP,” an “OpenAI MCP”? The fragmentation of such a critical protocol would severely hamper the vision of a truly unified external AI toolset. An open, community-driven standard is crucial for widespread adoption and true interoperability.

6. Contextual Understanding and Common Sense (The ‘Edan’ Gaps)

While AI is getting smarter, it still lacks true common sense and deep contextual understanding. A human developer can infer intent, understand implicit constraints, or know when a seemingly logical action might have unintended side effects because of historical context or team politics. AI agents are still largely reactive to explicit instructions and data. Bridging this gap remains a significant challenge.

The Future is ‘Gila’: An Agentic AI World

Despite the challenges, the trajectory is clear. The convergence of MCP and Skills is not just an incremental improvement; it’s a paradigm shift. We are moving towards a future where AI assistants are not just passive knowledge bases or code generators, but active, intelligent agents capable of orchestrating complex tasks across our entire digital infrastructure. This is the promise of truly “agentic AI” and the external AI toolset.

Imagine:

  • Your development environment is no longer just an IDE; it’s a dynamic, AI-powered command center.
  • Tasks like “Spin up a new staging environment for this feature branch, deploy the latest code, and notify QA” become single, natural language prompts.
  • AI agents will proactively monitor systems, suggest optimizations, and even self-heal minor issues before they become major incidents.
  • Developers become conductors of AI orchestras, focusing on architectural design, complex problem-solving, and teaching their agents new “skills.”

The “Google ADK and MCP with an external server” vision implies a future where AI agents are seamlessly integrated, pulling real-time data and leveraging powerful external services to perform increasingly sophisticated, real-world tasks. This is not just about boosting productivity; it’s about redefining the nature of work itself. The world of dev is about to get gloriously ‘gila’ (crazy) in the best possible way.

Conclusion: Embrace the Madness (with a Healthy Dose of Caution)

So, there you have it, my ‘Wong Edan’ deep dive into MCP and Skills. No more playing digital hopscotch between your AI assistant and your dev tools. The future is one where AI agents, empowered by a shared communication protocol and a modular library of capabilities, will operate seamlessly within our ecosystems, becoming true collaborators rather than siloed assistants.

This isn’t just about faster coding; it’s about fundamentally changing our interaction model with computers, moving towards a world where we delegate complex, multi-step tasks to intelligent agents that understand context, execute actions, and orchestrate workflows across diverse tools. The productivity boost will be real, substantial, and transformative.

But remember, every powerful tool demands responsibility. As we embrace this ‘gila’ future, let’s also champion security, reliability, and human oversight. Let’s build these systems thoughtfully, ensuring that our AI agents remain our powerful allies, augmenting our intelligence, and freeing us to tackle the truly challenging and creative aspects of software development. The revolution is here, my friends. Are you ready to dive in?