Author: Sladzana

  • Automattic’s WP Studio: Revolutionizing Local Development Workflows

    WordPress Studio (Automattic) & WP AI Capabilities

    Automattic’s New Agentic Local Workflow

    I’ve been testing out WordPress Studio for just under 10 days now. It’s been developed by the Automattic team and is aimed predominantly at developers working on WordPress.com sites (although it works very well with self hosted sites too). Direct sync isn’t included (only works with wordpress.com hosted sites) but you can easily export your packages.

    It comes complete with WP-CLI, Model Context Protocol (MCP) support and native agentic capabilities. It’s a very impressive, professional grade tool for building and testing block themes, testing plugins, debugging and scaffolding (with specific blueprints, yes blueprints for developers). It’s the same technology that powers WP Playground.

    Some of the components (Studio Desktop, the Studio CLI and Studio Code) are still in beta but I can confirm they’re fast and reliable. You can of course plug in your own AI agent client or use the one that comes built in which already has all the agentic skills it needs from the source.

    The ecosystem covers everything you need:

    • Studio CLI: Enables you to streamline your local WordPress development workflows right from the terminal.
    • Plugin Development: Hooks, the Settings API, security hardening and packaging.
    • Block Development: Block.json attributes, rendering logic and deprecations.
    • Block Themes: Theme.json, custom templates, patterns and style variations.
    • REST API: Routes, endpoints, schema handling, and authentication.
    • WP-CLI & Ops: core automation, search and replace, operational commands.

    While fiddling around with the local dev flow and the new AI features in WordPress I “got” a bonus of 100k AI credits to play with (block themes, test developer blueprints etc). I gave it an html layout and it produced the templates. I also tested out the new core feature in Woo advanced settings, tested out the AI abilities from various plugins and I also had a go at the Purple Theme (the new Woo block theme which has just been released for testing). Every site you spin up locally is a sandboxed process. Purple Theme is officially released.

    I gave the AI assistant the full logs and CLI system access for the purposes of testing and it was an absolutely intense experience. The results are excellent. It did run into one small SQL edge case during testing but the agent diagnosed and fixed that locally in seconds.

    Focused on its official (right from the source) WordPress and WooCommerce skills it remains very sharp and gets the job done safely.

    WP Studio lets you code smoothly inside your favorite IDE (like VS Code), backed by a ton of flexible options. I also made test in VS Code with other Agent so you are free to use your own API or Agent.

    If you are developing on WordPress and you have fun building your block themes, testing WP and WOO latest versions and possibilities like AI Abilities, this is the right tool to use. If you got curious to try it out, you can dive into its capabilities and setup guides via the link below.

    I must admit that, as an open-source project, with adding core AI features WP expands its capabilities far beyond its original purpose, proving that WordPress is no longer just for blogs, but it’s shaping up to be an AI integrated ecosystem.

    https://developer.wordpress.com/studio/

    Stay tuned my next post will be on WP Playground.

  • Claude Managed Agents -Shift From Model Output to System Execution

    Claude Managed Agents represent a shift in how large language models are deployed in practice, instead of producing isolated outputs, these systems are designed to execute multi-step tasks within controlled environments.

    This changes the role of AI systems from passive generators of responses to active components within execution workflows.

    The biggest risk is not that agents fail — but that they succeed in ways that were not fully anticipated.

    This shift reframes AI from a tool to an operator. That transition introduces both operational opportunity and new categories of risk, which is why security teams are closely monitoring this development.

    check my article on medium

    https://medium.com/@s.bogeska/claude-managed-agents-shift-from-model-output-to-system-execution

  • GitHub Copilot + Ollama: Local AI in VS Code

    How the Integration Works

    You can now run local AI models directly inside Visual Studio Code — without sending your code to the cloud.

    Thanks to the integration between GitHub Copilot Chat and Ollama, developers can switch between cloud-based models and locally running LLMs inside the same interface. This sounds like the ideal setup: private, cost-free, and fully under your control. This isn’t a complete replacement for cloud AI yet but it’s a flexible hybrid approach.

    Everything happens inside the GitHub Copilot Chat interface in Visual Studio Code — no extra tools or complex setup required. Once Ollama is running locally, its models become available directly in the Copilot Chat model picker. You can choose between:

    • Cloud models (like GPT-4-class models)
    • Local models running through Ollama

    Switching between them is seamless, so you can use:

    • local models for privacy-sensitive tasks
    • cloud models for more complex reasoning or better performance

    There’s no need for external APIs when using local models — they run entirely on your machine via Ollama.

    Prerequisites

    To use this setup, you’ll need:

    • Ollama (v0.18.3 or newer) running locally
    • Visual Studio Code (v1.113 or newer)
    • GitHub Copilot Chat extension (v0.41.0 or newer)

    You also need to be signed in to GitHub Copilot, but a paid subscription is not required. The free tier supports custom model selection.

    What You Can Do With It

    Once configured, you can use local models inside VS Code for:

    • Code generation
    • Explaining code
    • Debugging issues
    • Context-aware suggestions based on your workspace

    Limitations

    • Inline autocomplete still relies on cloud-based GitHub Copilot models
    • Local models can be noticeably slower, especially on mid-range hardware
    • Model quality varies, and smaller local models may struggle with complex tasks

    So while local models are useful, they don’t fully replace cloud AI in day-to-day development.

    When Local Isn’t Enough — BYOK

    If your machine can’t handle local models well, there’s a practical fallback: Bring Your Own Key. This lets you connect external model providers via API keys and use them inside the same Copilot interface — effectively offloading computation to the cloud.

    If you want access to multiple models without juggling multiple API keys, services like OpenRouter can simplify this by giving you a single key that works across many different models.

    This integration it’s about giving developers more control. In practice, local models can feel fast for short responses since there’s no network latency. However, for longer outputs or more complex tasks, cloud models still tend to be faster due to higher token generation speeds and more powerful hardware so that’s the major issue.

    You can keep sensitive code local when it matters, avoid unnecessary costs, and still rely on powerful cloud models when/if needed, so,

    It depends what you are working on, medium coding tasks, long complex tasks and if you are dealing with Privacy-critical work.

    Your real experience will depends on:

    Hardware

    • CPU
    • GPU

    Model size

    • 7B → fast
    • 30B → slower
    • 70B → slow (impossible locally)

    Context size

    • Bigger prompt = slower generation
    • Tools/agents/ = MUCH slower

    Cold start

    • Loading model = seconds delay

    https://medium.com/@s.bogeska/vs-code-ollama-integration-287302f7a594