We talk a lot about vibe coding. And to be honest, I’d heard the term far too many times before I took it seriously. It made no sense to me in the way that I think about vibes. How can you code based on a feeling? There are rules darn it (slams fits on desk). Well, apparently we can code based on vibes (but there are still rules).

Yes, we need to be careful when deploying apps on the web. But that doesn’t mean we can’t also have a little fun and take the easier route when possible. As someone who now works with Claude Code on a regular basis, and has used the prompt “I don’t like the way it looks please change everything and try again” more than once, I can confirm. It is absolutely easier.

Since the tooling environment is accessible to people from all backgrounds, I thought it would be useful to cover some basics. The remainder of this article will talk about what vibe coding is and some of its fundamentals so you too can tell Claude, “I don’t like the way it looks please change everything and try again.”

What is vibe coding?

Vibe coding lets developers focus on design decisions, constraints, and outcomes rather than syntax. It does so by using generative AI to build applications by describing the intent, architecture, and user experience of a system rather than manually writing every line of code.

Vibe coding helps people with and without a background in computer science or software development build applications.

Getting started with vibe coding

With traditional development, developers start assembling the pieces and working out different parts of the application. That could look like defining, building, and testing functions, loops, variables, etc. And once enough of the pieces are assembled, they’ll start assembling everything into a working system.

Vibe coding starts with vibes. Rather than working through a few functions, you can share your intent and desired functionality with generative AI and then AI will work out all the details.

Let’s think through something simple, adding a new UI to a page. The new UI should accomplish the following:

• iterate through an array
• render a component for each item
• display them in a list

In more traditional software development, you could start tackling the problem with this line of thinking: Create a loop that iterates through an array of task objects and renders a card component for each task.

With vibe coding, you’re focused more on describing the functionality and result rather than the build. The solution (aka the prompt) for the same task as above would look more like the following sentence. Build a responsive card list that displays tasks from an array. Each task should render as a card with clear spacing, dark-mode support, and a subtle hover animation.

The prompt communicates behavior and design intent, not just implementation details. If you prompted AI with more technical instruction, you may not get your desired outcome at this stage. Yes, there is a time and place for more technical instruction but we won’t cover that here.

Vibe coding tools

It’s clear we’re in the age of AI. My experience from this past year leads me to believe that working with AI is only going to continue getting easier, more efficient, and more impactful. So if you’re someone who vibe codes, I’d be on the lookout for new tools regularly.

Here are some popular tools that allow developers to treat AI as a collaborative layer in the development process rather than a separate system.

• Cursor is an AI-native integrated development environment (IDE) that understands your codebase and can generate or refactor code across files.
• GitHub Copilot is an AI-powered extension for existing IDEs like VS Code or JetBrains, providing inline code suggestions and generating code as you type.
• Replit is a platform for rapid prototyping and deployment, letting you generate and deploy apps quickly.
• Framer Motion is a declarative animation library for React that adds motion and interactions with minimal code.
• Tailwind CSS is a utility-first CSS framework that lets you describe design intent in plain, human-readable terms, making it easy for AI to translate your aesthetic into working styles.

Vibe coding prompt design

Truthfully, this section could be its own blog because there’s a ton to cover. There’s no perfect way to design a prompt, and better prompts will come from trial and error. But here are some simple principles to help you get started.

Structured prompts

The clearer the prompt, the closer the code will be to your desired results. Rather than asking for AI to build an app, help it understand the vibes. In this case, the vibes are problem, constraints, and desired experience. The C.A.S.E. Framework is one approach.

Context: What does the application do?
Example: A Pomodoro timer that helps users focus and take breaks during work sessions.

Aesthetic: What will the app look like? Are there any UI constraints?
Example: A clean dashboard layout with large numbers and minimal distractions. The timer sound should be soft and non-intrusive. 

Stack: What frameworks, libraries, or languages should it use?
Example: React and Tailwind CSS.

Experience: How will the application feel to the user?
Example: Calm, focused, and distraction-free.

Can you prompt AI with something like “Build a Pomodoro timer” and get a Pomodoro timer? Yes. Will it be the one you want? No. Yes, I know this from experience.

The examples above can be built into the structured prompt below:

• Build a Pomodoro timer using React for the frontend logic and Tailwind CSS for styling.
• Display a 25-minute countdown with Start and Reset buttons.
• Use a clean dashboard layout with large, readable numbers and generous whitespace.
• The experience should feel calm, distraction-free, and easy to focus on.
• We’ll use this for our code example.

You’re always welcome to include more detail in your prompts but I wouldn’t suggest including less. These prompts also help you, the developer, think through what you want the user to experience with your application.

Vibe coding a Pomodoro timer

Let’s turn our prompt into a real application. I’m going to use VS code and Gemini for this example. If you want to code along but don’t have the specific AI tooling, a chatbot is a great way to start.  I don’t usually vibe code with Gemini but it’s great for this example.

Note: Don’t vibe code with ChatGPT.  In my experience, ChatGPT writes code with bugs in it and can’t debug. It keeps you looped into doing the same thing over and over again. 

I pasted our prompt into Gemini exactly as it’s listed above. When you code with a chatbot like Gemini or Claude and work outside of that environment (i.e. copy/ paste into an IDE), it still helps with all the steps.

Gemini chose to build our React project with Vite. Vite is the industry standard for starting React projects these days because it’s incredibly fast.

Open your terminal and run:

npm create vite@latest my-pomodoro -- --template react

Then move into the project folder:

cd my-pomodoro

Then install dependencies and start the server:

npm install
npm run dev

Your app will go live athttp://localhose:5173.

The code below is Gemini’s response to our prompt:

Replace the code insrc/App.jsxwith the code below.

import { useState, useEffect } from 'react';
import './App.css';

function App() {
  const [minutes, setMinutes] = useState(25);
  const [seconds, setSeconds] = useState(0);
  const [isActive, setIsActive] = useState(false);

  useEffect(() => {
    let interval = null;

    if (isActive) {
      interval = setInterval(() => {
        if (seconds > 0) {
          setSeconds(seconds - 1);
        } else if (minutes > 0) {
          setMinutes(minutes - 1);
          setSeconds(59);
        } else {
          // Timer finished
          clearInterval(interval);
          setIsActive(false);
          alert("Time's up! Take a breath.");
        }
      }, 1000);
    } else {
      clearInterval(interval);
    }

    // This "cleans up" the timer if the user leaves the page
    return () => clearInterval(interval);
  }, [isActive, minutes, seconds]);

  const toggleTimer = () => setIsActive(!isActive);

  const resetTimer = () => {
    setIsActive(false);
    setMinutes(25);
    setSeconds(0);
  };

  // Helper to make "5" look like "05"
  const displayTime = (val) => String(val).padStart(2, '0');

  return (
    <div className="container">
      <div className="timer-card">
        <h1>Focus</h1>
        <div className="display">
          {displayTime(minutes)}:{displayTime(seconds)}
        </div>
        <div className="controls">
          <button className="btn-primary" onClick={toggleTimer}>
            {isActive ? 'Pause' : 'Start'}
          </button>
          <button className="btn-secondary" onClick={resetTimer}>
            Reset
          </button>
        </div>
      </div>
    </div>
  );
}

export default App;

Replace the code insrc/App.csswith the code below.

/* Calm Background & Base Reset */
body {
  margin: 0;
  padding: 0;
  background-color: #f0f4f8; /* Soft blue-grey */
  font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
  display: flex;
  justify-content: center;
  align-items: center;
  height: 100vh;
}

/* The Main Container */
.container {
  display: flex;
  justify-content: center;
  align-items: center;
  width: 100%;
}

/* The Card holding the timer */
.timer-card {
  text-align: center;
  background: white;
  padding: 5rem 6rem; /* Generous internal padding */
  border-radius: 32px;
  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.04);
  max-width: 500px;
  width: 90%;
}

/* "Focus" Title */
h1 {
  color: #627d98;
  font-weight: 300;
  text-transform: uppercase;
  letter-spacing: 0.2rem;
  margin: 0;
  margin-bottom: 5rem; /* Large gap below the title */
}

/* The Countdown Numbers */
.display {
  font-size: 8rem;
  font-weight: 700;
  color: #102a43;
  line-height: 1;
  margin-bottom: 5rem; /* Large gap below the numbers */
  font-variant-numeric: tabular-nums; /* Prevents numbers from jumping when they change */
}

/* Button Container */
.controls {
  display: flex;
  gap: 1.5rem;
  justify-content: center;
}

/* Shared Button Styles */
button {
  padding: 1.2rem 2.5rem;
  border-radius: 16px;
  border: none;
  font-size: 1.1rem;
  font-weight: 600;
  cursor: pointer;
  transition: all 0.2s ease;
  outline: none;
}

button:hover {
  opacity: 0.9;
  transform: translateY(-2px);
}

button:active {
  transform: translateY(0);
}

/* Specific Button Colors */
.btn-primary {
  background-color: #48bb78; /* Calm green */
  color: white;
}

.btn-secondary {
  background-color: #e4e7eb;
  color: #486581;
}

Your result will look like this:

What do you think? Is it an elegant, easy to understand, non-intrusive timer? Is it what you expected? What would you change or refine? Play with this a little. See how easy it is to change the amount of time on the timer. Press start, then pause. Get a feel for how it works then get started on something more exciting!

The post Beginners guide to vibe coding appeared first on The New Stack.

Announcing new agents for modernization that are built to scale and designed for control.

When you watch a live broadcast—like the Olympics Games or a major sporting event—you aren’t thinking about the coordination behind it. You simply experience the event. Out of sight, specialized teams synchronize cameras, replays, data, and commentary in real time. When that coordination works, complexity disappears.

This is how I think about AI agents. Each one observes a different signal and contributes a piece of the picture. Telemetry surfaces what’s happening, dependencies reveal how systems are connected and risks are surfaced as work progresses. The human stays in control throughout—deciding what to act on and how to validate outcomes.

This model matters because modernization is becoming one of the biggest opportunities in the AI era. In fact, according to Forrester’s Q1 2026 Cloud and AI Application Modernization Survey, 91% of IT leaders see application modernization as necessary to enabling AI advancements in their business.¹ However, many organizations still operate complex legacy estates with disconnected tools and months of manual planning just to decide what to modernize. IT and developers often work in parallel but without a shared view of the system. AI changes the dynamic, helping teams analyze environments, prioritize workloads, and accelerate modernization.

Today, we’re taking another step to help organizations adopt new AI capabilities with real business impact. We’re announcing the first agentic end-to-end modernization solution that brings IT and developers into a single, connected workflow. With expanded capabilities across Azure Copilot and GitHub Copilot, we are infusing AI through these tools to accelerate insight‑driven decisions and move modernization from analysis to action—faster and at scale.

AI agents make this possible by operating in parallel across discovery, assessment, planning, migration, and code transformation. They automate dependency mapping, generate decision ready plans, and guide execution inside the tools teams already use. Work that used to be slow, manual, and fragmented becomes coordinated and continuous as teams modernize across applications, infrastructure, data and code.

One system. One team.

The newest agentic teammate, Azure Copilot migration agent, is now in public preview. The migration agent helps organizations eliminate technical debt by embedding AI across discovery, assessment, planning, and deployment, reducing modernization timelines dramatically. It works for your most mission-critical servers, virtual machines, applications, and databases, turning migration from a one-time project into a continuous modernization motion.

The agent uses what customers already know about their environments to create this continuous modernization system providing early clarity on their inventory of servers, databases, applications and their dependencies, how it all works, what it costs, and what’s worth modernizing. What once took months of manual planning can now take minutes of conversation with the agent and a data-driven plan.

By reducing toil, closing skills gaps, and aligning IT and development teams through connected workflows, the Azure Copilot migration agent can help enterprises move to Azure faster, more confidently.

GitHub Copilot modernization capabilities also add to your modernization team with agents to transform legacy applications to become cloud and AI-ready. Embedded directly where developers work, these agents can pull assessments, build customized modernization plans for each application, execute upgrades, and deploy directly to Azure—all with developers in the driver’s seat.

And today, its newest capability, the modernization agent, is in public preview. The modernization agent allows you to go beyond individual applications and tackle modernization at scale, acting as an orchestrator to simultaneously run multiple code assessments, build unique modernization plans for each application, and execute the plans with automated framework and runtime upgrades. This is a major step forward in how application owners, architects, and developers can transform a broad set of applications at scale while keeping the customization needed for each application.

In a true multi‑agent experience, the modernization agent directs the broadcast—application owners and architects set direction, specialized agents execute, and developers stay in the loop to guide and validate.

Organizations have already seen success using GitHub Copilot capabilities made generally available this past fall, modernizing in hours instead of months with automated .NET and Java upgrades. For a recent customer, total modernization effort was reduced by 70%.² Today, with its connection to Azure Copilot migration agent and native integration within developer environments, GitHub Copilot modernization can transform applications end-to-end, with higher confidence outputs and control at every step.

Playing together for the win

Historically, infrastructure decisions—landing zones, networking, governance—were made upstream, without visibility into application realities. Developers modernized code without knowing how it would run, scale, or be governed in the target environment. This meant mismatches surfaced late, when fixes were most expensive.

With Azure Copilot and GitHub Copilot working together, that disconnect disappears. Agents help bridge developer‑level code insights with cloud migration and modernization planning. GitHub Copilot modernization capabilities scan application code to produce detailed code assessment reports, while Azure Copilot’s migration agent ingests those reports to surface code‑level issues, warnings, and insights. This integration allows Azure Copilot to incorporate real code analysis when assessing readiness and recommending the right Azure target, connecting developer‑driven modernization work with the cloud and infrastructure planning used by migration teams. You get AI guided migration and modernization planning with intelligent workload prioritization, cost visibility and automated wave recommendations.

Why your database is critical to modernization

Modernizing apps is only part of the journey. Your database is critical, because your AI strategy is only as strong as your data strategy. When data is fragmented or locked into aging infrastructure, even the most sophisticated agentic workflows hit a ceiling.

Moving to Azure managed database services readies your database for AI and transfers the operational burden of infrastructure management to a platform built to handle it. Fully managed services reduce overhead, improve resilience, and free teams to focus on building intelligent applications. The result is a data foundation that can scale with demand, meet security expectations, and stay ready for what AI workloads require.

Once your data estate is modernized on Azure, the destination is a unified data platform—where databases, analytics, and AI operate as one coherent estate. With AI capabilities natively built into Azure databases, organizations can build cloud-native AI applications that leverage semantic search, memory integration, and advanced model invocation. Those capabilities are grounded in Azure’s data layer, so models always work from the most current, trusted signals the business produces.

How modernizing on Azure empowers customers

Our agents are making more possible. We’re moving away from one-off use of agentic tools to consistent, repeatable agentic execution. This is the importance of pairing agentic tools with structured delivery models, so organizations can scale modernization confidently across teams and environments.

Ahold Delhaize, one of the world’s largest food retail groups, shared how they modernized their application and data estate on Azure to support AI-powered business outcomes. Using agentic tools across migration and modernization workflows, they reduced complexity, improved modernization collaboration across teams, and accelerated delivery.

By applying agents across discovery, assessment, and execution, Ahold Delhaize moved away from fragmented modernization efforts and toward a more continuous, intelligent process—one that provided confidence in both the plan and the execution.

Customer results like these point to the same conclusion: the future of modernization is agentic, connected, and human-led.

Cloud Accelerate Factory brings agentic modernization to life at scale

Agentic tools are redefining what’s possible, but outcomes scale when innovation is paired with execution. Cloud Accelerate Factory, a benefit of Azure Accelerate, helps organizations operationalize modernization with zero-cost, hands‑on delivery from specialized Microsoft experts.

As Microsoft’s first-party modernization delivery engine, Cloud Accelerate Factory works alongside customers and partners from discovery through production, applying a structured approach to modernization at scale across applications, infrastructure, and data—often in days, not months.

Combined with agentic capabilities like Azure Copilot and GitHub Copilot, Cloud Accelerate Factory helps organizations confidently modernize, fast, so that plans become measurable progress across key workloads including .NET, Java, and SQL.

Join the visionaries at the Microsoft Azure Summit

Get ready for a rich agenda at this year’s Microsoft Azure Summit: Migrate and Modernize with Agentic AI. This livestream event on March 12, 2026, (Asia and Europe) and April 23, 2026, (Americas) features interactive sessions led by Microsoft engineering with compelling customer stories and live demos of the latest innovations discussed in this blog. Hear directly from organizations that have successfully leveraged the latest agentic tooling and capabilities to migrate and modernize to Azure, and see firsthand how new offerings can make a tangible impact on your business.

This year’s summit features an impressive lineup of topics helping you build the future of cloud and AI.

• Keynote: Migrate and modernize with agentic AI
• Regional session (customized): Modernization for a sovereign, AI-ready figure
• Breakout: Accelerate and simplify planning, migration, and operations using AI agents
• Breakout: Reimagine application and database modernization with agentic tools

¹Forrester’s Q1 2026 Cloud and AI Application Modernization Survey [E-66670] Base: 223 Global leaders in charge of their organization’s cloud and AI strategy

²Accelerate migration and modernization with agentic AI, Amanda Silver, September 23, 2025

The post Many agents, one team: Scaling modernization on Azure appeared first on Microsoft Azure Blog.

Get caught up on the latest technology and startup news from the past week. Here are the most popular stories on GeekWire for the week of March 8, 2026.

Sign up to receive these updates every Sunday in your inbox by subscribing to our GeekWire Weekly email newsletter.

Most popular stories on GeekWire

The ‘Tesla exemption’ no more: Rivian and Lucid break through Washington state’s dealership wall

At the start of next year, Washington state shoppers will for the first time be able to visit showrooms for Rivian and Lucid Motors, take a test drive and buy an EV. … Read More

A whole new ballgame for trading cards: Startup uses robots and AI to sort and analyze collections

Gradient’s Renton, Wash., office space is home to 10 million sports and gaming cards, where a team of card geeks and engineers are using technology to upend a $15 billion U.S. … Read More

Microsoft’s return-to-office policy creates a return to slower commutes, traffic analysis shows

Inrix measured travel speeds on eastbound and westbound SR 520 and southbound and northbound I-405 during the weeks of Feb. … Read More

Opinion: You couldn’t pay me to leave Washington state, and I’d pay more to stay

My view on Washington’s proposed tax on very high incomes is simple: if I’ve found myself in the position of making that much in a year, I can afford to contribute a little more to the place that helped make that circumstance possible. … Read More

Contractors sue Modern Hydrogen, alleging the Bill Gates-backed startup left their final invoices unpaid

Five contractors are suing the Seattle-area clean energy startup for more than $363,458, alleging unpaid invoices when the company suddenly slowed operations late last year. … Read More

Atlassian layoffs impact 63 workers in Washington as CTO steps down

Atlassian announced Wednesday that it will lay off about 10% of its staff, or 1,600 employees, as the 24-year-old software firm transitions to an “AI-first company.” … Read More

Washington House passes 9.9% ‘millionaires tax’ as business leaders warn of ‘seismic shift’

Some tech leaders and entrepreneurs worry the legislation could undermine their sector by souring Washington’s relatively favorable tax laws for startup founders, investors and high-wage earners. … Read More

Tech Moves: Microsoft Research gets a new leader; Amazon head joins AI startup; JPMorgan exec departing

Igor Tsyganskiy is now leading Microsoft Research (MSR) as past president Peter Lee takes the helm of Microsoft Science. … Read More

New free, on-demand EV service launches in Redmond to shuttle riders to light rail

RedLink riders can access the service via the Circuit app. … Read More

Opinion: The wrong tax at the wrong time for Washington

Seattle entrepreneur Jesse Proudman on why he’s saddened by the state’s new income tax, writing that it comes at the “worst possible moment” amid the AI boom. … Read More

At this point, Edge has started to feel less like a browser and more like a home for Copilot, as the default experience literally opens Copilot, with its chat history on the left and a compose box in the center, including the ability to create images on the New Tab Page of what is supposed to be a browser.

It’s a fact that Microsoft hasn’t had much success with the Edge browser. It’s not even close to Google’s huge market share, but at the same time, Edge has been a great browser and a solid alternative to Chrome. Moreover, Microsoft’s embrace of Chromium has benefited Google more than anyone else, including Microsoft.

By switching to Chromium, Microsoft addressed compatibility issues while still maintaining Edge’s original design principles. Edge quickly gained some ground in the highly competitive browser industry with useful features like vertical tabs, Collections, and its own unique identity.

Fast forward to 2026, and Edge no longer feels like the browser some of us genuinely liked. The New Tab Page, where you would normally expect an address bar, shortcuts to frequently visited websites, and a nice wallpaper, has turned into a full-blown Copilot experience.

The default New Tab Page of Edge automatically opens a full-blown Copilot UI

Previously, Microsoft said it would add Copilot mode as an optional feature, but it doesn’t look like the company is really living up to its word.

Copilot in Edge is still optional, but it’s now turned on by default, and it almost feels like AI has hijacked the browsing experience.

For example, look at the above screenshot. It’s Edge’s home page with a Copilot compose box, and you can also access Copilot in the sidebar, so we have AI not once but twice. However, that’s not the worst part of the Copilotification of Edge.

I’m particularly frustrated with how the address bar sometimes sends me to Copilot rather than the website I am trying to open. Some of you should be able to reproduce this behavior. Open Edge, then immediately paste or type a URL, and the URL may be pasted into Edge’s Copilot compose box instead of opening the URL in a tab.

It doesn’t happen all the time, but if you do it enough times, you’ll run into this behaviour, and it’s likely a bug (or an edge case).

But can you completely disable AI in Edge?

You can’t permanently disable AI in Edge because the browser would still request Copilot in the background, but you can turn off some of the features so they don’t get in the way.

To disable some of these AI features, open Edge Settings, go to AI innovations, and toggle off Copilot mode.

Google Chrome also has Gemini integration, but it’s tucked into the title bar, which makes it less intrusive. Moreover, Google has spared the homepage, as AI only lives in the title bar.

Edge is still a good browser, but it’s just not the same anymore. It’s also losing its original design identity to Chromium/Chrome, as Microsoft continues to remove exclusive features such as the Edge sidebar, Collections, and even icons from the right-click menu, which now looks much more like Chrome’s.

The post Microsoft Edge feels more like Copilot than a browser now, but some AI features can be turned off appeared first on Windows Latest