Over the past weeks, I experimented with vibe coding while building a simple app with complex logic. It’s fun and it definitely compresses time-to-prototype — but it also reinforced a timeless lesson: speed without structure is expensive later.

What works well

• Quick exploration of ideas and UX flows.
• Unblocking unknowns: “Can this even work?”
• Generating momentum for stakeholders and teams.

Where it bites back

• Hidden coupling and unclear boundaries.
• Weak tests and flaky behavior under change.
• Onboarding friction: the next developer slows down.

The balance that works for me

• Timebox the prototype — agree it will be thrown away or hardened.
• Capture decisions — note trade-offs and assumptions as you go.
• Stabilize early — add tests, interfaces, and clear module contracts.
• Refactor to patterns — before adding features, make the shape right.

For me, vibe coding is a booster, not a destination. It shines when used to learn fast — and then replaced (or refactored) with code that’s maintainable, testable, and ready for a team.

Tags: #Prototyping #SoftwareEngineering #CleanArchitecture #Testing #DevEx

In the age of AI, it feels like everyone can be a developer. With a few prompts, we can generate working code, scaffold entire applications, or even automate documentation. It’s exciting — and a little bit surreal — to see how far we’ve come.

But as someone who’s spent years building backend systems, designing architectures, and leading engineering teams, I’ve learned that writing code has never been the hardest part of software development. AI has made coding easier — but engineering is still about something deeper.

The difference between code and engineering

Writing code is an act of creation. Engineering is an act of design. A good engineer doesn’t just make a feature work — they make it fit into a system that others can understand, maintain, and extend. They think about scalability, performance, and failure scenarios long before they happen.

Where AI helps — and where it doesn’t

AI can now write decent code, generate unit tests, and even propose optimizations. It’s an incredible assistant. But what AI still struggles with is context — understanding trade-offs, designing boundaries, and thinking in systems rather than snippets. Our job is shifting from writing code to orchestrating intelligence — both human and artificial — to build reliable and meaningful software.

The human side of engineering

Good engineers solve problems. Great engineers make it easier for others to solve them. When everyone can write code, the value shifts to those who can architect, govern, and scale it sustainably. AI won’t replace that anytime soon.

Closing thought

The future belongs to those who can blend technical precision with human judgment. Code may be generated by machines — but engineering will always be a human art.

Tags: #AI #SoftwareEngineering #Leadership #DotNet #Azure #BackendDevelopment

Over the past couple of weeks, I’ve been using Google Antigravity, and I didn’t expect it to leave this kind of impression on me. I try a lot of AI tools for development, but this is the first one that genuinely made me pause and rethink how AI fits into my daily workflow.

What makes Antigravity stand out isn’t just speed or code generation — it’s understanding. It feels less like a tool that responds to prompts and more like a system that understands intent.

Where It Really Shines: Frontend Development

Frontend development is where Google Antigravity truly excels. From layout structure to UI flow, it consistently produces results that feel intentional and well thought out. Turning an idea into a working interface happens incredibly fast, and the quality is surprisingly high.

Instead of fighting boilerplate or repetitive UI tasks, I found myself focusing more on product decisions and user experience — which is exactly where developers should spend their time.

Backend: Promising, but Still Evolving

On the backend side, Antigravity isn’t perfect yet. Some areas still need refinement, and you can tell it’s an evolving product. That said, the foundation is clearly there. With continued improvements, it has the potential to become a strong full-stack companion rather than just a frontend powerhouse.

Why This Matters

What impressed me most is how Antigravity changes the feeling of development:

• Less friction
• Faster experimentation
• More room for creativity
• Less mental fatigue

It’s one of the first AI tools that made building things feel genuinely enjoyable again.

Final Thoughts

Google Antigravity feels like a glimpse into where AI-assisted development is heading. It’s not perfect — and that’s okay — but it already delivers real value, especially for frontend work.

If you’re a developer, product builder, or someone who enjoys creating software, this is absolutely worth trying. I didn’t expect to be this impressed, but here we are.

Tags: #GoogleAntigravity #AI #WebDevelopment #Frontend #Productivity

In short: in under two weeks I took Deskforce, a desktop app where AI agents work as a team, from first commit to a signed release on three operating systems, with automated tests, a documentation site and a Docker image. Testing it on real work exposed a weakness most multi-agent systems share. I measured it and fixed it.

🎯 The Problem

Companies want AI agents to take real work off their teams. Two things stop them: they can't see what the agents are doing, and they can't control what it costs or undo what went wrong. Agent frameworks leave that to you; demos skip it.

🏗️ What I Built

Deskforce treats AI agents like a small company: you hire employees, each on the model you choose, give the CEO a goal, approve the plan and its cost estimate, and watch the work get delegated and built. The decisions that make it usable for real work:

• Control before autonomy: nothing is built until a person approves the plan; every task has a budget, and there is a monthly cap.
• Every change is reversible: each task is a git commit in the employee's name, undone with one click.
• Rules instead of hope: employees only delegate to more junior roles, at most three levels deep, so work can't spiral.
• Security by design: it only answers on the user's own machine, rejects requests from other websites, keeps model-written files inside their project, and blocks agents from reaching private network addresses.
• Any model: OpenAI, Claude, Gemini, Grok or a local model, with a fallback for models that can't call tools.

🧪 How It Was Engineered

• Tests that don't need an API key: a fake provider speaks four providers' streaming formats, so the real integrations and whole tasks are tested offline, plus a browser test of the full app: 93 automated tests on every change.
• Release engineering: a signed and notarised macOS app, Windows and Linux installers, automatic updates, and a multi-platform Docker image. Every installer is started automatically before a release goes out.
• Diagnosed, not guessed: the Docker image never got published, because its ARM half, built under emulation, stalled until the 6-hour limit. Moving it to native ARM build machines took it from 6+ hours to about 3 minutes.
• Documentation as part of the product: a documentation site, an architecture guide, contributor guides and examples with real costs.

📊 Measured Results

• A bakery landing page by four employees on gpt-4o: $0.11, about 45 seconds.
• A flower-shop landing page, planned on gpt-4o and built on grok-3: $0.16, about a minute.
• The same landing page on three models: $0.001 (gpt-4o-mini), $0.02 (gpt-4o) and $0.07 (grok-3).

The most expensive model cost 70 times more, and for that job it was clearly worth it. For well-specified work, the cheap one was often enough. Knowing the difference is worth more than the token prices themselves.

🔍 The Weakness I Found, and Fixed

When work was split between several agents, the pieces drifted apart: a four-page website came back with none of its pages using the stylesheet, and the AI reviewer reported it as "fully delivered". A command-line tool passed its tests but couldn't run.

Instead of tuning prompts until a demo looked good, I added an automatic check that reads the project for places where files don't fit together (missing links and imports, unused stylesheets, unreachable pages, code that runs before its functions exist) and gives the findings to the reviewing agent. On a rerun of the same website, the problems went 17 → 1 → 0 through the manager's follow-up and the final review.

💡 What This Means for Your Project

• Measure before you scale: cost, time and quality per model, on your own tasks.
• Keep people in control: approvals, budgets and a full history of what the AI changed.
• Don't trust AI to check AI alone: pair the model with deterministic checks.
• Ship it like software: tests, CI, security and documentation from the start.

If you're planning AI features, agents, or the backend to run them on, book a free 15-minute call. The code is on GitHub.

Tags: #CaseStudy #AI #AIAgents #SoftwareEngineering #DotNet #Azure #Deskforce

Four AI employees. One bakery landing page. About a minute of work. Total cost: $0.11.

That was a real run of Deskforce, a project I've just released as open source. It's a virtual office of AI agents: you hire a team, give the CEO a goal, and watch the work get planned, delegated and built.

🤔 Why I Built It

Multi-agent AI is everywhere right now, but using it day to day is still awkward. You usually end up with one of two things:

• Agent frameworks (CrewAI, LangGraph, Microsoft Agent Framework): great for building agents into your own product, but you design, host and debug the system before anything useful happens.
• Multi-agent platforms (ChatDev 2.0, MetaGPT / MGX): you build workflows on a canvas or hand a prompt to a hosted team, and follow the run through logs.

In both cases the same questions come up: What is the agent doing right now? How much will this cost? And how do I undo what it just did?

I wanted an app you install, add a key to, and start using, where you can actually see the work happening and stay in control of it.

🏢 How It Works

Deskforce treats AI agents like a small company:

• You give a request to your most senior employee, the CEO.
• The CEO writes a plan with a cost estimate and a breakdown of who does what.
• You approve it, edit it, or ask for another plan. Nothing is built before that.
• Work gets delegated down the hierarchy. Juniors can only pass work further down, never back up.
• Agents use tools: they read and write project files, search the web, and ask their manager (or you) when they're stuck.
• Every finished task becomes a git commit in the employee's name.
• The CEO reviews everything at the end, fixes gaps, and writes you a report.

In the bakery example, Leo the designer worked on the layout and visuals, Sam the copywriter wrote the hero section and menu, Robo the junior dev built the contact form, and Quinn from QA checked that it worked on different screens. The finished page opens in a preview inside the app.

👀 You Can Watch Them Work

This is my favourite part. Every employee is an avatar on an office floorplan, and speech bubbles show what each model is writing as it writes it. Next to the floorplan there's a task tree showing who's working on what, how many tokens each task used, and what it cost.

Instead of scrolling through logs to understand what went wrong, you just look at the office.

🧠 A Model Per Employee

Not every job needs your most expensive model. In Deskforce you choose a model for each employee:

• A strong model for the CEO and reviewers, who plan and check the work
• A cheaper, faster model for junior staff doing simpler tasks
• Any provider: OpenAI, Claude, Gemini, Grok, or a local model through Ollama

With Ollama, nothing leaves your machine at all. And if you don't have a key yet, providers answer with mock text so you can try the interface first.

💰 Costs You Can Control

An agent stuck in a loop can burn through a budget before you notice. Deskforce has several checks against that:

• ✅ Plan approval: you see the estimated cost before anything is spent
• 🎯 A budget per task, plus a monthly cap
• 📊 Spending broken down by day, employee and model
• ⚖️ Side-by-side model comparisons, to find the cheapest model that's still good enough

↩️ Undo Anything

Because every task is a git commit in the employee's name, you always know who changed what. If you don't like a change, revert it with one click. You can give agents real work without worrying that one bad step will ruin the whole project.

💬 Works From Slack

You don't have to sit in front of the app. You can ask for work, check progress, and approve plans from a Slack message, without exposing your computer to the internet.

🚀 Try It

Deskforce runs on your own computer, so your files stay with you:

• macOS (Apple Silicon and Intel) and Windows: download the desktop app from the Releases page and add your API keys in settings
• Linux: an AppImage or a .deb from the same page, or run it with Docker
• From source: clone the repo, run npm install and npm run dev (Node.js 22+)

Start small: hire a few employees, give the CEO a task, and watch what happens. The getting started guide covers the rest.

🛠️ Need a Custom Version?

Deskforce is free and MIT-licensed, including for commercial use. If you'd like it built around your company, with your own roles and approval steps, integrations with your tools, private or self-hosted models, your branding, or a hosted multi-user version, I build custom versions. Get in touch and I'll send you a proposal.

The source is on GitHub. Stars, issues and pull requests are all welcome. ⭐

Tags: #AI #AIAgents #MultiAgent #LLM #OpenSource #Ollama #DeveloperTools #Deskforce

AI-generated code is fast… but not always secure.

Research is showing what many of us are starting to notice in real projects:

👉 The Problem

AI tools can generate code that works… but often introduces security vulnerabilities:

• Insecure defaults
• Missing authentication
• Injection vulnerabilities
• Bad validation

And the scary part? These issues often look "clean" and pass reviews under time pressure.

✅ The Solution: Use AI Against AI

If AI can generate code, it can also:

• 🔍 Detect vulnerabilities — automatically scan for security issues
• 🛠️ Propose fixes — generate secure patches
• ✅ Open PRs with secure patches + tests — integrate directly into your workflow

Why This Matters

Because security can't stay a manual checklist.

As teams move faster with AI-generated code, we need automated security layers that move just as fast. Manual code reviews are essential, but they can't catch everything — especially when deadlines are tight.

🤖 The Future of Secure Development

AI should not only write code — it should protect it.

Tools like Repovate are already making this possible by analyzing codebases, detecting security flaws, and automatically generating secure fixes. This is DevSecOps at the speed of AI.

The real question isn't whether AI will write more code — it's whether we'll let it write insecure code.

Tags: #AI #CyberSecurity #DevSecOps #AppSec #SoftwareEngineering #Automation #Repovate