Category: Artificial Intelligence

  • Best AI Coding Tools in 2027, Compared by Real Workflows

    Best AI Coding Tools in 2027, Compared by Real Workflows

    The best AI coding tools in 2027 are Cursor for an AI-first code editor, Claude Code for terminal-based agent work, GitHub Copilot for teams already on GitHub, OpenAI Codex for ChatGPT subscribers and Google Antigravity as the strongest free option. For building apps without coding, Replit, Bolt and v0 are the best vibe coding tools.

    I sorted these tools by the work developers actually do day to day: fixing bugs in old code, building new features, reviewing pull requests and turning a rough idea into a working prototype. This guide sorts them by workflow, not by hype, and every price was checked on the vendor’s own page in November 2026.

    Key Takeaways

    • Pick by workflow first: an AI code editor, a terminal agent, a GitHub-native assistant or a browser app builder.
    • Most paid plans now start at $8 to $30 a month, with $100 to $200 tiers for heavy agent use.
    • Windsurf is now Devin Desktop, and Google moved individual Gemini CLI and Code Assist users to Antigravity in June 2026.
    • Developers use AI widely but do not fully trust it, so code review and tests matter more than ever.
    • Vibe coding tools are great for prototypes; production apps still need a developer to check security and structure.

    1. What Counts as an AI Coding Tool in 2027?

    The four types of AI coding tools in 2027: AI code editors, terminal and cloud agents, editor assistants and vibe coding tools

    AI coding tools now fall into four groups, and most developers end up using two of them together.

    • AI code editors are full editors with AI built in, such as Cursor, Devin Desktop and Antigravity. They suggest code as you type and run agents inside your project.
    • Terminal and cloud agents, such as Claude Code and OpenAI Codex, take a task in plain English, edit files, run commands and hand back a change for you to review.
    • Editor assistants, such as GitHub Copilot, plug into the editor you already use, including VS Code, JetBrains IDEs, Visual Studio and Xcode.
    • Vibe coding tools, such as Replit, Bolt and v0, build and host a whole app from a chat in your browser, with little or no code written by you.

    If you are new to vibe coding, our guide to writing vibe coding prompts that produce production-ready code explains how to brief these tools well.

    2. The Best AI Coding Tools Compared

    Here is how the main tools compare on type, free access and starting price for one person.

    ToolTypeFree optionPaid plans (USD per month)Best for
    CursorAI code editorYes, limitedPlus $8 (Grok models only), Premium $30, Super $100, Ultra $200Developers who want AI built into the editor
    Claude CodeTerminal, IDE, desktop and web agentNo (Free Claude plan does not list Claude Code)Pro $20 ($17 billed yearly), Max $100, Ultra $200Large, multi-file changes from the terminal
    GitHub CopilotEditor assistant and cloud agentYes, limited chat and agent usePro $10, Pro+ $39, Max $100Teams that live in GitHub
    OpenAI CodexCloud, CLI and IDE agentYes, limitedGo $8, Plus $20, Pro from $100People who already pay for ChatGPT
    Devin Desktop (formerly Windsurf)AI code editor with an agent managerYes, light quotaPro $20, Max $200Running several agents from one place
    Google AntigravityAgent-first editor, CLI and desktop appYes, weekly quotaThrough Google AI Pro ($20) or Ultra ($100 or $200)The most generous free option
    ReplitBrowser app builderYesCore $20, Pro $100Full apps with a database, built in the browser
    BoltBrowser app builderYes, 1M tokens a monthPro $25Fast websites and app prototypes
    v0 by VercelBrowser app and UI builderYes, 7 messages a dayPlus from $30 per userReact and Next.js interfaces deployed to Vercel
    Prices are list prices for one user, billed monthly, as shown on each vendor’s pricing page on November 12, 2026. Taxes are extra and prices change often, so check the vendor page before you buy.

    Key insight: the sticker price is rarely the real cost. Most of these tools meter agent usage, so a heavy week of agent tasks can push you to the next tier.

    3. Best AI Code Editor: Cursor

    Cursor is the best pick if you want one editor where autocomplete, chat and agents all work on your whole codebase.

    Cursor is built on the same base as VS Code, so most extensions and shortcuts carry over. Its paid plans add cloud agents and automations, AI code reviews through Bugbot, and code hosting. The Plus plan at $8 a month only includes Grok models, while Premium at $30 a month unlocks third-party models, which are billed separately at API list price. Cursor plans are now also bundled with Grok and X features.

    Cursor works best for developers who spend most of the day in an editor. Cloud agents also let you start work from the browser, which we covered in our look at the Cursor web app and cloud agents.

    4. Best Terminal Agent: Claude Code

    Claude Code is the strongest choice for big, multi-file tasks you describe once and then review.

    Anthropic describes Claude Code as an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools. It runs in the terminal, in VS Code and JetBrains, in a desktop app and on the web. It comes with the Claude Pro plan at $20 a month ($17 a month billed yearly), with Max at $100 and Ultra at $200 for people who run agents all day.

    Claude Code is a strong fit for refactors, test writing and “read this old project and explain it” tasks. It suits developers who are comfortable reviewing diffs rather than watching every keystroke.

    5. Best for GitHub Teams: GitHub Copilot

    Copilot is the easiest tool to roll out across a team because it works inside the editors and GitHub workflows people already use.

    Copilot runs in VS Code, Visual Studio, JetBrains IDEs, Xcode, Neovim, Eclipse and Zed, plus a command-line tool. The Free plan includes limited chat and agent use. Pro costs $10 a month, Pro+ $39 and Max $100, and each plan includes GitHub AI Credits that agent mode, code review and the cloud agent draw from. On paid plans you can assign an issue to Copilot and it opens a pull request.

    6. Best for ChatGPT Users: OpenAI Codex

    If you already pay for ChatGPT, Codex is included and covers the web, the command line and your IDE.

    OpenAI lists a free tier, Go at $8, Plus at $20 and Pro from $100 a month, with Pro available at $100, $200 or $500. Plus adds Codex on the web, in the CLI, in the IDE extension and on iOS, along with automatic code review and a Slack integration. Business costs $20 per user a month billed yearly for two or more users.

    7. Best Agent Command Center: Devin Desktop (Formerly Windsurf)

    Devin Desktop is the new name for Windsurf, and it suits developers who want to manage many agents from one screen.

    Cognition renamed Windsurf on June 2, 2026. Its FAQ says Devin Desktop is the same IDE, same editor, and has the same features, with the Agent Command Center as the main view. Cognition also says it is making Devin Desktop compatible with other agents via ACP. The Pro plan costs $20 a month and Max costs $200, and Pro includes access to Devin Cloud agents.

    8. Best Free AI Coding Tool: Google Antigravity

    Antigravity has the most useful free tier in this list, and it is now Google’s main coding product for individuals.

    Google stopped serving Gemini Code Assist IDE extensions and Gemini CLI for individual, Google AI Pro and Google AI Ultra accounts from June 18, 2026, and moved those users to Antigravity. The free individual plan includes unlimited Tab completions and a weekly quota. Google AI Pro raises the limits, and Google’s docs say Ultra users get the highest quota and access to third-party models. Google lists Pro at $20 a month and Ultra at $100 or $200 a month.

    If you read older guides that recommend Gemini CLI as a free option for personal accounts, that advice no longer applies.

    9. Best Vibe Coding Tools: Replit, Bolt and v0

    Vibe coding tools turn a plain-English description into a working, hosted app, which makes them ideal for founders and designers testing ideas.

    ToolFree planPaid planWhat stands out
    ReplitYesCore $20 ($18 billed yearly), Pro $100 ($90 billed yearly)Databases, AI integrations and up to 15 collaborators on Pro
    Bolt300K tokens a day, 1M a monthPro $25, Teams $30 per memberHosting, unlimited databases and custom domains on Pro
    v07 messages a dayPlus from $30 per user, Business $100 per userDesign Mode, GitHub sync and one-click deploys to Vercel
    Monthly prices from each vendor’s pricing page, November 12, 2026.

    These tools get you to a demo in an afternoon. Before real users touch it, check the security basics in our vibe coding security rules, because generated apps often ship with exposed keys, weak access rules or missing input checks.

    Key insight: vibe coding tools are best at the first 80% of an app. The last 20%, including security, payments and performance, is where a developer still earns their fee.

    10. Do AI Coding Tools Actually Make You Faster?

    Usage is close to universal, but trust and measured speed gains are mixed, so treat AI output like a junior developer’s first draft.

    In Stack Overflow’s 2025 survey, 84% of respondents were using or planning to use AI tools in development, and 51% of professional developers used them daily. Yet more developers actively distrust the accuracy of AI tools (46%) than trust it (33%).

    A METR randomized trial found that experienced open-source developers using early-2025 AI tools took 19% longer to finish tasks in their own repositories. METR calls this a snapshot of early-2025 tools, and the tools have improved a lot since, but the lesson holds: AI speeds up some work and slows down other work.

    Many developers pair tools, for example an editor for daily work and a terminal agent for bigger jobs. Our write-up on pairing OpenCode with Cursor shows one such setup.

    Key insight: measure your own team. Track pull requests merged, bugs found in review and time to ship for a month before and after you adopt a tool.

    11. How to Choose the Right AI Coding Tool

    Which AI coding tool to start with, matched to six common workflows

    Choose by the work you do every day, then run a two-week trial on a real project before you commit a team.

    If you…Start with
    Write code all day in an editorCursor or Devin Desktop
    Prefer the terminal and big, multi-file tasksClaude Code or Codex CLI
    Run a team on GitHub with JetBrains or Visual Studio usersGitHub Copilot
    Already pay for ChatGPT or ClaudeCodex or Claude Code, which come with those plans
    Want a capable tool for $0Google Antigravity or Copilot Free
    Are not a developer and want a working appReplit, Bolt or v0
    • Check which models each plan includes, since cheaper tiers may limit them.
    • Read how usage is metered and what happens when you hit the limit.
    • Confirm data and privacy terms before you connect company code.
    • Make code review and automated tests a rule, whatever tool you pick.

    Frequently Asked Questions

    What is the best AI coding tool for beginners?

    For beginners who want to learn to code, GitHub Copilot Free or Google Antigravity’s free plan are good starts because they cost nothing and explain code as you go. For people who only want a working app, Replit or Bolt are easier because they handle hosting and setup for you.

    What is the best free AI coding tool?

    Google Antigravity has the most generous free individual plan in 2027, with unlimited Tab completions and a weekly agent quota. GitHub Copilot Free, Cursor’s free plan and Devin Desktop’s free plan are also useful, but their agent and chat limits are tighter.

    Is Cursor better than GitHub Copilot?

    Cursor is better if you want an editor built around AI agents and are happy to switch editors. Copilot is better if your team uses several editors or relies on GitHub for issues and pull requests, because it fits into the tools you already have. Both have free plans, so try each on the same task.

    What are vibe coding tools?

    Vibe coding tools build software from plain-English instructions, so you describe what you want and the tool writes, runs and often hosts the code. Replit, Bolt and v0 are popular examples. They are excellent for prototypes, but production apps still need a developer to review security and structure.

    Will AI coding tools replace developers?

    Not on current evidence. Surveys show most developers use AI but many distrust its accuracy, and controlled studies show mixed speed results. AI is changing the job toward planning, reviewing and testing, so developers who use these tools well become more valuable, not less.

    The Bottom Line

    There is no single best AI coding tool, but there is a best tool for each workflow, and most teams do well with two.

    Start with one editor tool and one agent, give them real work for two weeks, and keep strict code review in place. Use vibe coding tools for fast prototypes, and bring in a developer before anything handles customer data or payments.

    If you have a prototype that needs to become a secure, production-ready product, our team at Infyways handles web development for businesses, with AI tools in the workflow and humans reviewing every change.

    Sources

    1. Cursor, “Pricing”. Checked November 12, 2026.
    2. Anthropic, “Claude plans and pricing”. Checked November 12, 2026.
    3. GitHub, “Copilot plans and pricing”. Checked November 12, 2026.
    4. OpenAI, “Codex pricing”. Checked November 12, 2026.
    5. Cognition, “Devin plans and pricing”. Checked November 12, 2026.
    6. Google, “Google Antigravity pricing”. Checked November 12, 2026.
    7. Replit, “Pricing”. Checked November 12, 2026.
    8. Bolt, “Plans and pricing”. Checked November 12, 2026.
    9. Vercel, “v0 plans and pricing”. Checked November 12, 2026.
    10. Anthropic, “Claude Code overview” documentation. Checked November 12, 2026.
    11. Cognition, “Devin Desktop FAQ”. Checked November 12, 2026.
    12. Cognition, “Windsurf is now Devin Desktop”. June 2, 2026.
    13. Google for Developers, “Gemini Code Assist consumer accounts” deprecation notice. Checked November 12, 2026.
    14. Google, “Plans” (Google Antigravity documentation). Checked November 12, 2026.
    15. Google, “Changes to Antigravity plans”. 2026.
    16. Stack Overflow, “2025 Developer Survey: AI”. 2025.
    17. METR, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity”. July 10, 2025.
  • How to Build an AI Agent in 2027: Frameworks, No-Code Builders and a Step-by-Step Plan

    How to Build an AI Agent in 2027: Frameworks, No-Code Builders and a Step-by-Step Plan

    To build an AI agent, pick one narrow task, give a large language model a clear instruction, two to five well-described tools, and a loop that checks results after every step. Start with a framework like the OpenAI Agents SDK or LangGraph, or a no-code builder like n8n, then add tests, guardrails and human approval before it touches real data.

    Plenty of business owners see an AI agent demo and want one for their own team. The honest answer is that a useful agent is simpler than the demos suggest, and a risky one is easier to build than most people think.

    Interest is real. McKinsey’s 2025 survey found 62% of respondents say their organizations are at least experimenting with AI agents, but only 23% report scaling an agentic system anywhere in the business. Gartner goes further and predicts over 40% of agentic AI projects will be canceled by the end of 2027, due to costs, unclear value or weak risk controls.

    This guide is the plan I would use to land on the right side of that number: what an agent is, when you need one, how to build it step by step, and which frameworks and no-code builders fit which job.

    Key takeaways

    1. What Is an AI Agent?

    An AI agent is software where a language model decides which steps to take and which tools to call to complete a goal, checking the results as it goes.

    McKinsey defines AI agents as systems based on foundation models capable of acting in the real world, planning and executing multiple steps in a workflow. In practice, an agent has four parts:

    • A model that reasons about the next step.
    • Instructions that set its role, limits and stopping rules.
    • Tools, such as a search function, a database query or an API call, that let it act.
    • A loop that feeds each tool result back to the model until the task is done or a limit is reached.

    Anthropic draws a useful line between two designs. Workflows are systems where LLMs and tools are orchestrated through predefined code paths, while agents let the model direct its own process and tool use.

    If you want the wider picture of how agents differ from generative AI and agentic AI, read our guide to generative AI vs AI agents vs agentic AI.

    Key insight: most business “agents” that work well in production are really workflows with one or two decision points handled by a model.

    2. Do You Actually Need an AI Agent?

    When to use a workflow vs an AI agent: workflows for fixed steps, agents when the steps depend on the input

    You need an agent only when the steps cannot be predicted in advance. If the steps are known, a workflow is cheaper, faster and easier to test.

    Anthropic notes that agentic systems often trade latency and cost for better task performance, and that for many applications a single well-built LLM call with retrieval is enough. Gartner makes a similar point: many use cases positioned as agentic today don’t require agentic implementations.

    QuestionUse a workflowUse an agent
    Are the steps the same every time?YesNo, they depend on the input
    Can you write the process as a flowchart?YesOnly roughly
    How much does a wrong action cost?Any level (easier to control)Low, or every action is approved by a person
    Do you need predictable cost and speed?YesYou can accept variation
    ExamplesSummarize every new support ticket, route leads by rulesResearch a question across sources, fix a failing test, triage messy requests
    Decision guide based on Anthropic’s “Building effective agents” (workflows vs agents) and our own project experience.

    A good test: if you can draw the process on a whiteboard without any “it depends” boxes, build a workflow. Keep agents for the “it depends” parts.

    3. How to Build an AI Agent Step by Step

    How to build an AI agent in eight steps: pick a task, choose the model, design tools, write instructions, add memory, test, add guardrails, then deploy and monitor

    Building an agent takes eight steps, and the same steps apply whether you write code or use a no-code builder.

    Step 1: Pick one narrow, measurable task

    Choose a task with a clear finish line, such as “answer order-status questions using our order system” or “draft a reply for every new support email”. Write down what success looks like and how you will measure it.

    Step 2: Choose the model

    Start with a capable general model from a major provider and measure quality before you optimize cost. Anthropic suggests routing easy questions to smaller, cost-efficient models and hard ones to more capable models as one way to save money later.

    Step 3: Design the tools

    Tools are functions the agent can call. Keep the list short, give each one a clear name and description, and make inputs hard to get wrong. Anthropic says its team spent more time optimizing tools than the overall prompt while building a coding agent.

    If your tools already live in other apps, the Model Context Protocol (MCP) gives agents a standard way to connect to them. Our guides on MCP vs API and building your first MCP server show how it works in practice.

    Step 4: Write the instructions

    Write a system prompt that states the role, the goal, what the agent must never do, when to ask a person for help and when to stop. Add a maximum number of steps so a confused agent cannot loop forever.

    Step 5: Add memory and knowledge

    Give the agent access to the documents it needs through retrieval-augmented generation (RAG). Our guide to a production RAG pipeline covers chunking, search and evaluation.

    Step 6: Test with real examples

    Collect 20 to 50 real requests, including awkward ones, and check every answer and every tool call. Re-run the same set after each change so you can see whether quality went up or down.

    Step 7: Add guardrails and human approval

    Limit what each tool can do, validate inputs and outputs in code, and require a person to approve anything risky, such as refunds, emails to customers or database changes. OWASP recommends you require human approval for high-risk actions and restrict the model’s access privileges to the minimum necessary.

    Step 8: Deploy, monitor and improve

    Log every run, including the tool calls, cost and outcome. Review failures weekly, add them to your test set, and only widen what the agent is allowed to do once it has earned that trust.

    Key insight: the test set from Step 6 is the most valuable thing you build. It tells you whether a new model, prompt or framework is actually better.

    4. AI Agent Frameworks Compared

    Frameworks handle the loop, tool calling and state for you. The best choice depends on your language, your cloud and how much control you want.

    FrameworkMaintainerMain languageLicenseBest for
    OpenAI Agents SDKOpenAIPython (GitHub)MITA light, quick start with handoffs between agents
    LangGraphLangChainPython (GitHub)MITStateful, multi-step agents that need fine control
    CrewAICrewAIPython (GitHub)MITTeams of role-based agents working together
    Agent Development Kit (ADK)GooglePython (GitHub)Apache-2.0Teams building on Google Cloud and Gemini
    Microsoft Agent FrameworkMicrosoftPython and .NET (Go in preview)MIT (GitHub)Teams building on Azure and .NET
    Pydantic AIPydanticPython (GitHub)MITType-safe agents with structured, validated outputs
    License and primary language from each project’s GitHub repository, checked November 12, 2026. “Best for” is our summary of each project’s own documentation.

    Anthropic also suggests trying LLM APIs directly before adopting a framework, because many patterns take only a few lines of code. Whatever you pick, make sure you can see the prompts and tool calls it sends.

    5. No-Code AI Agent Builders

    No-code builders let you assemble an agent from visual blocks and ready-made app connections, which suits operations teams and quick pilots.

    BuilderFree optionPaid entry priceAgent featuresWatch out for
    n8nSelf-hosted Community Edition€20/month (Starter, billed annually)AI Agent node, MCP client and server, human approval for tool callsCloud prices are in euros; executions are capped by plan
    Zapier AgentsFree plan includes 400 agent activities/monthPro from about $33.33/month (annual) for 1,500 activitiesAgents act across Zapier’s 9,000+ app connectionsAgent activities are billed separately from Zap tasks
    Prices and limits from each vendor’s pricing page, checked November 12, 2026. Prices change often, so check before you buy.

    n8n can run on your own server, which keeps data in-house. Our step-by-step guides cover installing n8n with Docker, installing it with npm and hosting it on DigitalOcean. The n8n Advanced AI docs explain its agent nodes in detail.

    If you would rather learn agent development properly before you build, a structured course that covers tool calling, RAG, evaluation and deployment will save you a lot of trial and error. Check that it includes a hands-on project, not just theory.

    6. How to Keep an AI Agent Safe, Tested and Affordable

    Treat every input an agent reads as untrusted, give each tool the smallest possible permissions, and watch cost per task from day one.

    Prompt injection is the biggest risk. OWASP explains that indirect prompt injections occur when an LLM accepts input from external sources, such as websites or files, which is exactly what agents do all day.

    • Keep secrets and API keys in your code, never in the prompt.
    • Separate read-only tools from tools that change data, and gate the second group behind approval.
    • Validate tool inputs and outputs with code, not with another prompt alone.
    • Set limits on steps, run time and spend per task.
    • Log everything, so you can explain any action the agent took.

    Skills in this area are in demand. Lightcast found the agentic AI skill cluster grew from 0.06% of U.S. job postings in 2024 to 0.23% in 2025, about 90,000 postings. If you want to build agents for a living, our guide on how to become an AI engineer sets out the full path.

    7. Which Way Should You Build Your Agent?

    Match the tool to the team: no-code for operations pilots, a light SDK for developers starting out, and a full framework for complex, long-running agents.

    Your situationGood starting point
    Operations team, no developers, needs results this monthn8n or Zapier Agents
    Developer building a first agentOpenAI Agents SDK or Pydantic AI
    Complex agent with branching, retries and long-running stateLangGraph
    Several specialist agents that hand work to each otherCrewAI or OpenAI Agents SDK handoffs
    Company standardized on Google Cloud or AzureGoogle ADK or Microsoft Agent Framework
    Sensitive data that must stay on your serversSelf-hosted n8n or a framework on your own infrastructure

    Frequently Asked Questions

    How do I build an AI agent with no code?

    Use a no-code builder such as n8n or Zapier Agents. Connect the apps the agent needs, add an AI agent step with a clear instruction, give it a few actions as tools, and test it on real examples. Add an approval step before any action that sends messages, spends money or changes records.

    What is the best AI agent framework?

    There is no single best framework. The OpenAI Agents SDK and Pydantic AI are light and quick to learn, LangGraph gives the most control over complex state, CrewAI suits teams of role-based agents, and Google ADK or Microsoft Agent Framework fit teams already on those clouds. Pick the one that matches your language and stack.

    How much does it cost to build an AI agent?

    A simple no-code agent can start on a free plan, such as n8n’s self-hosted Community Edition or Zapier’s free plan with 400 agent activities a month. Costs then come from model usage, hosting and the time spent testing. Custom agents connected to business systems cost more, mainly in engineering and testing time.

    Can I build an AI agent in Python?

    Yes. Python is the main language for most agent frameworks, including the OpenAI Agents SDK, LangGraph, CrewAI, Google ADK and Pydantic AI. You can also start with an LLM provider’s API directly and add a framework only when you need features like state management or multi-agent handoffs.

    Are AI agents safe to use with company data?

    They can be, with the right controls. Give each tool the minimum permissions it needs, keep credentials out of prompts, treat outside content as untrusted, and require a person to approve high-risk actions. OWASP’s guidance on prompt injection is a good checklist to work through before launch.

    The Bottom Line

    Build your first AI agent around one narrow task, a few well-designed tools and a real test set, and keep a person in the loop for anything risky.

    Start with a workflow, add agent decisions only where the steps truly vary, and widen the agent’s permissions as it proves itself. That is how agents end up in production instead of on the canceled-projects list.

    If you want help designing or building an agent around your own systems, our team at Infyways works on automation and AI agent projects for businesses.

    Sources

    1. McKinsey, “The state of AI in 2025: Agents, innovation, and transformation”. November 5, 2025.
    2. Gartner, “Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027”. June 25, 2025.
    3. Anthropic, “Building effective agents”. December 19, 2024.
    4. OWASP Gen AI Security Project, “LLM01:2025 Prompt Injection”. 2025.
    5. Model Context Protocol, official documentation. Checked November 12, 2026.
    6. OpenAI, “OpenAI Agents SDK” documentation. Checked November 12, 2026.
    7. GitHub, openai/openai-agents-python repository (license and language). Checked November 12, 2026.
    8. LangChain, “LangGraph overview” documentation. Checked November 12, 2026.
    9. GitHub, langchain-ai/langgraph repository (license and language). Checked November 12, 2026.
    10. CrewAI documentation. Checked November 12, 2026.
    11. GitHub, crewAIInc/crewAI repository (license and language). Checked November 12, 2026.
    12. Google, “Agent Development Kit (ADK)” documentation. Checked November 12, 2026.
    13. GitHub, google/adk-python repository (license and language). Checked November 12, 2026.
    14. Microsoft Learn, “Microsoft Agent Framework overview”. Checked November 12, 2026.
    15. GitHub, microsoft/agent-framework repository (license). Checked November 12, 2026.
    16. Pydantic, “Pydantic AI” documentation. Checked November 12, 2026.
    17. GitHub, pydantic/pydantic-ai repository (license and language). Checked November 12, 2026.
    18. n8n, “Plans and Pricing”. Checked November 12, 2026.
    19. Zapier, “Pricing” (including Agents add-on). Checked November 12, 2026.
    20. n8n Docs, “Advanced AI”. Checked November 12, 2026.
    21. Lightcast, “The Stanford AI Index Report 2026” (labor market highlights). 2026.
  • How to Become an AI Engineer in 2027: Skills, Roadmap and Courses

    How to Become an AI Engineer in 2027: Skills, Roadmap and Courses

    To become an AI engineer, learn Python and core machine learning, then learn to build software on top of large language models (LLMs): prompting, retrieval-augmented generation (RAG), agents, evaluation and deployment. Ship two or three real projects, add one cloud AI certification if your target employers ask for it, and apply for roles where software and AI meet.

    That is the short answer. The longer one matters, because advice online ranges from “just learn prompting” to “get a PhD first”, and neither is right for most people.

    The demand is real. LinkedIn ranked AI engineer as the fastest-growing job in the U.S. in its Jobs on the Rise 2026 list, and AI skills appeared in 2.5% of all U.S. job postings in 2025, up 55% on the year before, according to Lightcast data for the Stanford AI Index.

    This guide turns that demand into a plan: what the role is, what it pays, the skills employers list, a step-by-step roadmap, and which courses and certifications are worth your time in 2027.

    Key takeaways

    1. What Is an AI Engineer?

    An AI engineer is a software engineer who designs, builds and runs applications that use AI models, especially large language models, in real products.

    LinkedIn describes AI engineers as people who develop and implement AI models that perform complex tasks typically requiring human decision-making, like problem-solving and prediction. It also notes the title overlaps with “machine learning engineer”.

    In practice, most AI engineering work in 2026 sits one layer above the model. You pick a foundation model, connect it to company data, give it tools, test its answers and keep it running at a sensible cost.

    Typical day-to-day tasks include:

    • Building chat, search and assistant features with an LLM API or an open-weight model.
    • Designing retrieval-augmented generation (RAG) pipelines so the model answers from your own documents.
    • Building agents that call tools and APIs to finish multi-step tasks.
    • Writing evaluations that measure accuracy, safety, speed and cost.
    • Deploying, monitoring and improving those systems in production.

    If the difference between generative AI, AI agents and agentic AI is still fuzzy, start with our guide to generative AI vs AI agents vs agentic AI.

    Key insight: an AI engineer is judged on whether the AI feature works reliably for users, not on how impressive the demo looked.

    2. AI Engineer vs ML Engineer vs Data Scientist vs Software Developer

    AI engineers build AI-powered products, ML engineers train and serve models, data scientists find answers in data, and software developers build the wider application.

    The titles overlap, and many job ads mix them. Here is the usual focus of each role.

    CriteriaAI engineerML engineerData scientistSoftware developer
    Main goalShip AI features that work in a productTrain, deploy and scale ML modelsTurn data into insights and predictionsBuild and maintain applications
    Typical workLLM apps, RAG, agents, evaluationTraining pipelines, feature stores, model servingAnalysis, statistics, experiments, dashboardsFront end, back end, APIs, testing
    Core languagePython (plus TypeScript for apps)PythonPython, SQL, RVaries (JavaScript, Java, C#, Python…)
    Key toolsLLM APIs, LangChain, vector databases, PyTorchPyTorch, MLOps and cloud ML platformspandas, SQL, notebooks, BI toolsFrameworks, databases, CI/CD
    Math depth neededModerateHighHigh (statistics)Low to moderate
    Usual way inFrom software engineering or data scienceFrom data science or software engineeringFrom statistics, math or analyticsComputer science degree, bootcamp or self-taught
    Closest BLS median pay (May 2025)$135,980 (software developers)$140,300 (research scientists)$120,230$135,980
    Pay figures are BLS national medians for the closest federal occupation, May 2025. BLS has no separate “AI engineer” or “ML engineer” category. Role descriptions are a general summary, and individual job ads vary.

    LinkedIn data backs up the “usual way in” row: the top roles people moved from into AI engineering are software engineer, data scientist and full-stack engineer.

    3. AI Engineer Salary and Job Outlook in the U.S.

    BLS does not track “AI engineer” as its own job, but the closest occupations pay median wages between about $120,000 and $140,000 and are projected to grow much faster than average.

    BLS figures for the three nearest occupations:

    For comparison, the median wage for all U.S. occupations was $50,980 in May 2025.

    Demand signals point the same way. CBS News reported that, between 2023 and 2025, LinkedIn added 639,000 AI-related job postings in the U.S., 75,000 of them for AI engineer roles.

    Location still matters. Lightcast found that California had 170,881 AI job postings in 2025, followed by Texas and New York, and LinkedIn lists San Francisco, New York City and Dallas as the top hiring areas for AI engineers.

    Key insight: treat salary figures as ranges, not promises. Pay depends on location, seniority and whether the employer sees the role as research, product engineering or something in between.

    4. AI Engineer Skills Employers Ask For

    AI engineer skills in four groups: programming and software engineering, machine learning foundations, LLM application engineering, and production and responsibility

    Employers want strong Python and software engineering first, then hands-on experience with LLM application patterns, cloud deployment and evaluation.

    Python leads the list. Lightcast found Python was the most in-demand specialized skill in AI job postings, appearing in 258,674 postings, up nearly 30% from 2024. Stack Overflow’s survey also shows Python adoption rose 7 percentage points from 2024 to 2025.

    The skills that show up most often fall into four groups:

    Programming and software engineering

    • Python, plus Git, testing, APIs and SQL.
    • Enough TypeScript or JavaScript to ship a simple front end.
    • Docker and basic cloud services.

    Machine learning foundations

    LLM application engineering

    Production and responsibility

    5. AI Engineer Roadmap: How to Become an AI Engineer Step by Step

    AI engineer roadmap in seven steps: Python and software basics, machine learning fundamentals, first LLM applications, RAG, tools and agents, evaluation and deployment, a portfolio, then certification and applying

    The fastest route for most people is seven steps: Python, ML basics, LLM apps, RAG and agents, evaluation and deployment, a portfolio, then targeted applications.

    Treat each step as a milestone, not a deadline. A working developer will move faster than a complete beginner.

    Step 1: Get solid at Python and software basics

    Learn Python well enough to write clean, tested code, call APIs, handle data with pandas and use Git. If you already work as a developer, focus on Python idioms and data handling.

    Step 2: Learn machine learning fundamentals

    Learn how supervised learning, loss functions, evaluation metrics and neural networks work. Good starting points include the Machine Learning Specialization from DeepLearning.AI and Stanford Online, a three-course program, and fast.ai’s Practical Deep Learning for Coders, which fast.ai offers as a free course for people with some coding experience.

    Step 3: Build your first LLM applications

    Use an LLM API to build a small chatbot, a summarizer and a structured-data extractor. The Hugging Face LLM Course, which Hugging Face describes as completely free, covers transformers and open models. Our guide to writing prompts that produce production-ready code helps with the prompting side.

    Step 4: Add RAG, tools and agents

    Connect a model to your own documents with embeddings and a vector database. Then give it tools, such as search, a database or an API, and build a simple agent that completes a multi-step task.

    Step 5: Learn evaluation, deployment and cost control

    Write tests for your AI features, measure accuracy and failure cases, and deploy on a cloud platform with logging. Track cost per request and response time from the start.

    Step 6: Build a portfolio of two or three real projects

    Pick problems with real users or real data: a support assistant for a real knowledge base, a document-processing pipeline or an internal agent. Publish the code, a short write-up and the evaluation results for each one.

    Step 7: Get certified if it helps, then apply

    Add one cloud certification if your target employers use that cloud (see the next section). Apply for AI engineer, applied AI and LLM engineer roles, and for software roles on AI product teams. These are often the easiest way in.

    Key insight: a deployed project with honest evaluation numbers tells a hiring manager more than a long list of course certificates.

    6. AI Engineer Certifications and Courses Worth Considering

    Certifications are optional. They help most when they match the cloud your target employer uses, and they work best alongside a portfolio.

    CertificationProviderExam fee (U.S.)FormatRecommended experienceBest for
    Machine Learning Engineer – AssociateAWS$150 (MLA-C02 beta: $75)65 questions, 130 min (MLA-C01); 85 questions, 170 min (MLA-C02 beta)About 1 year with SageMaker AI, Bedrock and other AWS ML servicesML and MLOps engineers on AWS
    Generative AI Developer – ProfessionalAWS$30075 questions, 180 min2+ years of cloud experience (per AWS)Developers shipping generative AI on AWS
    Professional Machine Learning EngineerGoogle Cloud$200 (plus tax where applicable)50–60 multiple-choice questions, 2 hours3+ years in industry, including 1+ year on Google CloudML engineers on Google Cloud
    Azure AI Apps and Agents Developer Associate (AI-103)MicrosoftAssociate exams typically $165 (Microsoft FAQ)120 min, proctoredPython app development, familiarity with generative AI and AzureAI engineers building agents on Azure
    Fees, formats and requirements are taken from each provider’s official certification page, checked November 12, 2026. Prices can change and may vary by country, so confirm before you book.

    One change to note: Microsoft retired the Azure AI Engineer Associate (AI-102) exam on June 30, 2026. AI-103 is the current Azure exam for this role.

    For learning (as opposed to certification), these structured options cover the roadmap above:

    7. Which Path Fits You?

    The right first step depends on what you already know.

    If you are…Start withSkip or postpone
    A software developerSteps 3–5: LLM apps, RAG, agents and evaluationA full math refresher; learn the math as you need it
    A data scientist or analystSteps 4–5: production engineering, APIs and deploymentBasic ML courses you have already covered
    A complete beginnerSteps 1–2: Python and ML fundamentalsProfessional-level certifications until you have shipped projects
    A career changer from a non-tech fieldSteps 1–3, plus one domain project from your current industryExpensive programs before you know you enjoy the work

    One practical tip: LinkedIn reports that 26.2% of AI engineer jobs were remote and 27.1% hybrid. That widens the pool if you live outside the main hiring hubs.

    Frequently Asked Questions

    How long does it take to become an AI engineer?

    It depends on where you start. A working software developer can often build job-ready LLM projects within several months of focused study. A complete beginner usually needs longer, because Python and ML basics come first. LinkedIn found that people hired as AI engineers had a median of 3.7 years of prior work experience, so most arrive from another tech role.

    Do you need a degree to become an AI engineer?

    Not always, but it helps. BLS says software developers typically need a bachelor’s degree in computer science or a related field, and research scientist roles typically need a master’s degree. For product-focused AI engineering jobs, many employers weigh shipped projects and engineering experience heavily, so a strong portfolio can offset a non-traditional background.

    How much does an AI engineer make in the U.S.?

    BLS does not publish an “AI engineer” category. The closest occupations had May 2025 medians of $135,980 for software developers, $140,300 for computer and information research scientists and $120,230 for data scientists. Actual offers vary widely by location, seniority and employer.

    Which programming language should an AI engineer learn first?

    Learn Python first. Lightcast found that Python was the most in-demand specialized skill in AI job postings in 2025, and nearly every major AI framework and model API has a Python SDK. Add TypeScript or JavaScript later if you want to build full AI products with a web front end.

    Is an AI engineer certification worth it?

    A certification is worth it when it matches the cloud your target employer uses, such as AWS, Google Cloud or Azure. It does not replace a portfolio, so earn it alongside real projects, not instead of them.

    The Bottom Line

    To become an AI engineer in 2027, get strong at Python, learn enough ML to understand your models, then build and ship real LLM applications with RAG, agents and proper evaluation.

    Pick one cloud, add a certification only if your target employers use that cloud, and let two or three deployed projects do the talking. The demand data is on your side, but shipped work is what gets you hired.

    If you are on the other side of the table and need AI features built into your product, our team at Infyways builds Python, machine learning and AI solutions for businesses.

    Sources

    1. LinkedIn News, “LinkedIn Jobs on the Rise 2026: The 25 fastest-growing roles in the U.S.”. January 7, 2026.
    2. Lightcast, “The Stanford AI Index Report 2026” (labor market highlights). 2026.
    3. U.S. Bureau of Labor Statistics, Occupational Outlook Handbook: Software Developers, Quality Assurance Analysts, and Testers. Last modified august 27, 2026.
    4. U.S. Bureau of Labor Statistics, Occupational Outlook Handbook: Computer and Information Research Scientists. Last modified august 27, 2026.
    5. U.S. Bureau of Labor Statistics, Occupational Outlook Handbook: Data Scientists. Last modified august 27, 2026.
    6. CBS News, “This is the fastest-growing job for young workers, LinkedIn says”. 2026.
    7. Stack Overflow, “2025 Developer Survey: Technology”. 2025.
    8. Model Context Protocol, official documentation. Checked november 12, 2026.
    9. NIST, “AI Risk Management Framework”. Checked november 12, 2026.
    10. DeepLearning.AI and Stanford Online on Coursera, “Machine Learning Specialization”. Checked november 12, 2026.
    11. fast.ai, “Practical Deep Learning for Coders”. Checked november 12, 2026.
    12. Hugging Face, “LLM Course”. Checked november 12, 2026.
    13. AWS, “AWS Certified Machine Learning Engineer – Associate”. Checked november 12, 2026.
    14. AWS, “AWS Certified Generative AI Developer – Professional”. Checked november 12, 2026.
    15. Google Cloud, “Professional Machine Learning Engineer”. Checked november 12, 2026.
    16. Microsoft Learn, “Microsoft Certified: Azure AI Apps and Agents Developer Associate”. Checked november 12, 2026.
    17. Microsoft Learn, “Exam frequently asked questions” (exam pricing). Checked november 12, 2026.
    18. Microsoft Learn, “Exam and assessment lab retirement”. Checked november 12, 2026.
  • Generative AI vs AI Agents vs Agentic AI: The Guide That Will Save You Millions

    Generative AI vs AI Agents vs Agentic AI: The Guide That Will Save You Millions

    I’ve been in the trenches with AI implementations for three years now, and I’m about to share something that will shock you.

    92% of companies are planning to increase their AI investments over the next three years, but here’s the brutal reality: only 1% call themselves “mature” on AI deployment.

    Why? Because they’re confusing three completely different technologies: generative AI, AI agents, and agentic AI.

    After analyzing thousands of AI implementations and consulting with Fortune 500 companies, I’ve discovered that most businesses are throwing money at the wrong solutions. They’re trying to use generative AI for tasks that need AI agents, or expecting AI agents to handle complex workflows that require agentic AI systems.

    This confusion is costing companies millions in failed AI projects. But it doesn’t have to cost you.

    1. What Is Generative AI (And Why Most Businesses Get It Completely Wrong)

    Generative AI is the content creation powerhouse that everyone thinks they understand—but most people are using it for all the wrong things.

    When you type a prompt into ChatGPT, Claude, or any large language model, you’re using generative AI. It’s a pattern-matching machine that creates new content based on statistical probabilities from its training data. Exploring different generative AI models can help businesses identify the right tool for each type of content or task.

    For professionals looking to build practical skills and understand how these technologies work, enrolling in a gen AI course can provide valuable hands-on knowledge of generative AI applications.

    But here’s where 90% of businesses mess up: they try to use generative AI for complex, multi-step workflows. It’s like trying to perform surgery with a hammer—sure, you might get some results, but there are much better tools for the job.

    Key insight: Generative AI is reactive, not proactive. It sits there waiting for your command, then responds based on patterns it learned. It cannot take initiative or perform autonomous multi-step reasoning.

    Here’s what generative AI actually excels at:

    • Content creation (blog posts, emails, product descriptions)
    • Code generation and debugging assistance
    • Language translation and localization
    • Summarization of existing documents
    • Creative brainstorming and ideation

    The real game-changer? Generative AI usage jumped from 55% to 75% among business leaders in just the last year. But most of them are still treating it like a magic solution for everything.

    2. AI Agents: The Single-Task Automation Revolution Everyone’s Talking About

    AI agents are where the real business transformation starts happening—but they’re not what most people think they are.

    Unlike generative AI that just creates content, an AI agent performs specific tasks using multiple tools and data sources. Think of it as a digital employee with a very specific job description.

    Here’s the reality check: what’s commonly called “agents” in the market today is just the addition of basic planning and tool-calling capabilities to large language models. True AI agents are still in early development stages.

    But when they work, they’re incredible. Let me share a real example that blew my mind:

    I worked with an e-commerce company that built an AI agent for customer service. This single agent:

    • Analyzed customer purchase history in real-time
    • Checked current inventory levels across warehouses
    • Processed returns and exchanges automatically
    • Generated personalized product recommendations
    • Updated customer records without human intervention

    The result? They reduced customer service costs by 67% while improving response times from 24 hours to under 2 minutes.

    The game-changer: AI agents can perform goal-oriented tasks autonomously. They don’t just respond to prompts—they execute complete workflows end-to-end.

    Popular frameworks for building AI agents in 2025:

    • LangChain: Perfect for beginners, extensive documentation
    • AutoGen: Microsoft’s multi-agent framework with enterprise focus
    • CrewAI: Role-based AI agent orchestration
    • LangGraph: For complex, graph-based agent workflows

    3. Agentic AI: When Multiple AI Systems Orchestrate Like a Symphony

    If AI agents are digital employees, agentic AI is the entire management team working together to solve problems no single agent could handle.

    This is where things get really exciting. Gartner predicts that by 2028, around 78% of enterprise software applications will harness agentic AI capabilities, up from virtually 0% today.

    Agentic AI represents the next evolution in artificial intelligence. Instead of one AI doing one job, you have multiple specialized AI agents collaborating, delegating tasks, and even supervising each other’s work.

    Here’s a mind-blowing example from a content marketing agency I recently consulted for:

    They built an agentic AI system that converts YouTube videos into complete blog posts. Here’s how the agent orchestra performs:

    • Transcription Agent: Downloads and transcribes video content
    • Analysis Agent: Identifies key topics, themes, and audience insights
    • Research Agent: Gathers additional data, statistics, and supporting evidence
    • Writing Agent: Creates structured, SEO-optimized blog content
    • SEO Agent: Optimizes for search engines and adds metadata
    • Quality Agent: Reviews, fact-checks, and refines final output

    The breakthrough result? They increased content production by 340% while maintaining higher quality than their previous human-only processes.

    The revolutionary insight: Agentic AI systems handle complex, multi-step workflows requiring different types of expertise—just like high-performing human teams.

    4. The Critical Differences That Determine Your AI ROI in 2025

    Understanding these differences isn’t academic—it’s the difference between AI success and expensive failure.

    Here’s what I’ve learned from working with hundreds of AI implementations: the companies that get these distinctions right are pulling ahead fast. The ones that don’t are wasting massive budgets on the wrong solutions.

    When to Use Generative AI

    • Content creation at scale for marketing teams
    • Quick brainstorming and ideation sessions
    • First drafts of marketing materials and communications
    • Code snippets and technical documentation
    • Simple question-answering scenarios

    When to Deploy AI Agents

    • Customer service automation and support
    • Data analysis and automated reporting
    • Lead qualification and nurturing workflows
    • Inventory management and supply chain optimization
    • Executive assistant tasks and scheduling

    When to Implement Agentic AI Systems

    • Complex workflow automation across departments
    • Multi-step process optimization
    • Strategic planning and execution coordination
    • Large-scale content operations
    • Enterprise-wide decision support systems

    The hidden cost of confusion? I’ve seen companies spend $500,000 building agentic AI systems for tasks that generative AI could handle for $50 per month. On the flip side, I’ve watched businesses struggle with manual processes that a simple AI agent could automate completely.

    5. The 2025 Implementation Framework That Actually Works

    Start with assessment, not technology—this single shift will save you more money than any other decision you make this year.

    Before you invest in any AI solution, map out your specific use cases with surgical precision:

    • Problem Definition: What exactly are you trying to solve?
    • Success Metrics: How will you measure ROI and business impact?
    • Complexity Evaluation: Is this single-step or multi-step process?
    • Integration Requirements: What systems need to work together?

    Then choose your technology stack:

    • Simple content generation = Generative AI
    • Task automation with external data = AI Agent
    • Complex workflow coordination = Agentic AI

    The Multimodal AI Revolution

    2025 is seeing explosive growth in multimodal AI that processes text, images, audio, and video simultaneously. This isn’t just a nice-to-have—it’s becoming essential for competitive advantage.

    Financial services companies are already using multimodal AI to analyze market commentary videos, considering non-verbal cues like tone and facial expressions alongside spoken words for nuanced market sentiment analysis.

    The Responsible AI Imperative

    Here’s something that will keep you up at night: 99% of companies in North America and Europe recognize the urgent need for ethical AI practices, but most haven’t implemented proper governance frameworks.

    The companies that get responsible AI right aren’t just avoiding disasters—they’re gaining massive competitive advantages through improved operational utility and corporate culture.

    Final Results: The Real-World Impact You Can Expect

    Companies that understand these distinctions are already seeing transformational results:

    • Cost Reduction: Companies implementing scalable AI are cutting operational costs by up to 30%
    • Productivity Gains: Proper AI implementation is boosting productivity across entire organizations
    • Process Automation: Complex workflows that took days now complete in hours
    • Customer Experience: Response times improving from hours to minutes
    • Revenue Growth: AI-powered personalization driving significant sales increases

    But here’s the reality check: experts predict that early AI agents will start with small, structured internal tasks with minimal financial risk. Don’t expect to turn these systems loose on real customers spending real money without extensive testing and human oversight.

    Genai vs ai agents vs agentic ai table

    Conclusion: Your AI Strategy Starts Today

    The bottom line? Generative AI creates content, AI agents perform specific tasks, and agentic AI orchestrates complex workflows. Each has its place in your AI strategy, but only if you use them correctly.

    Agentic AI workflows are expected to increase eightfold by 2026. The companies that understand these distinctions today will be the ones dominating their industries tomorrow.

    Don’t let another quarter pass while your competitors gain ground with properly implemented AI solutions. The window for early adoption advantages is closing fast, but there’s still time to position your business as an AI leader in your industry.

    Start by picking one use case that perfectly matches one of these technologies. Build it, measure the results, and scale from there. Your future self—and your bottom line—will thank you for making the right choice today.

    Ready to stop spinning your wheels and start building AI solutions that actually move the needle? The technology exists. The frameworks are proven. The only question is: will you be one of the 1% that gets AI implementation right, or will you join the 99% still figuring it out?

  • 30 Security Rules Every Vibe Coder Must Follow Before Shipping to Production

    30 Security Rules Every Vibe Coder Must Follow Before Shipping to Production

    Vibe coding is incredible.

    You can ship a full SaaS product in a weekend. Features that used to take a senior dev three days now take three hours. The speed is real.

    But here is what nobody tells you when they post their “I built this in 2 hours” thread on X.

    Speed without security is just a faster way to get hacked.

    Let me give you some real numbers. A December 2025 study tested five of the most popular vibe coding tools including Cursor, Claude Code, Replit, and Devin across 15 applications. The output contained 69 total vulnerabilities. Around half a dozen were rated critical. A separate Veracode study found that 45% of AI-generated code still contains classic vulnerabilities from the OWASP Top-10 list, with little improvement over two years. And just last week, a Lovable-built app leaked over 18,000 users’ data because the AI implemented the access control logic completely backwards. Authenticated users were blocked. Unauthenticated users got full access.

    A human reviewer would have caught that in seconds.

    The problem is not vibe coding. The problem is shipping vibe coded apps without understanding what the AI actually built.

    I have been building and shipping software for years. Here are the 30 security rules I follow on every single project. No exceptions.

    Authentication and Sessions

    Rule 1: Set session expiration properly

    JWT tokens should have a maximum life of 7 days combined with refresh token rotation. Never issue tokens that live forever.

    const token = jwt.sign(
      { userId: user.id },
      process.env.JWT_SECRET,
      { expiresIn: '7d' }
    );
    

    Pair this with refresh token rotation so that every time a refresh happens, the old token is invalidated. One leaked token should not last forever.

    Rule 2: Never use AI-built auth

    This is non-negotiable.

    Authentication is the most security-critical part of your entire stack. AI generates plausible-looking auth code that has subtle logic flaws. The Lovable breach mentioned above? Classic AI auth logic inversion.

    Use Clerk, Supabase Auth, or Auth0. These are battle-tested, maintained by security teams, and handle the edge cases AI will miss every single time.

    Rule 3: Never paste API keys into AI chats

    When you paste a key into an AI chat to get help with a bug, you have no idea where that key goes. Use environment variables always.

    // Never do this
    const client = new OpenAI({ apiKey: "sk-abc123yourrealkeyhere" });
    
    // Always do this
    const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
    

    Add your .env file to .gitignore before you write a single line of code. Which brings us to the next rule.

    Project Setup

    Rule 4: .gitignore is your first file, not your last

    Before you scaffold the project. Before you install packages. Before you do anything.

    Create .gitignore.

    Add .env, node_modules, .DS_Store, and any local config files before your first commit. One accidental push of a .env file to a public repo and your keys are compromised within minutes. GitHub scanners and credential harvesters run constantly.

    Rule 5: Rotate secrets every 90 days minimum

    Set a calendar reminder. Every 90 days, rotate your API keys, database credentials, and webhook secrets. If you suspect a breach at any point, rotate immediately.

    This is not paranoia. This is hygiene.

    Rule 6: Verify every package the AI suggests actually exists

    This one is genuinely scary and not enough people talk about it.

    AI models sometimes suggest packages that do not exist. Attackers monitor for this and register those package names with malicious code inside. It is called slopsquatting, and it is a growing threat vector in 2026.

    Before you run npm install on any package the AI recommends, check npmjs.com or pypi.org. Make sure the package exists, has real downloads, and has recent maintenance activity.

    Rule 7: Always ask for newer, more secure package versions

    When asking AI to scaffold your project, add this to your prompt: “Use the latest stable and most secure version of every package. Flag any deprecated dependencies.”

    Old packages have known CVEs. AI models trained on older data will suggest older package versions by default unless you explicitly ask for newer ones.

    Rule 8: Run npm audit fix right after building

    Make this a habit you cannot break.

    npm audit fix
    

    Run it after every major scaffolding session. Review the output. If there are high or critical vulnerabilities that cannot be auto-fixed, address them manually before you ship anything.

    Input, Data, and Queries

    Rule 9: Sanitize every input. Use parameterized queries always.

    SQL injection is still the most exploited vulnerability in web applications in 2026. AI-generated code frequently skips this.

    // This will get you hacked
    const query = `SELECT * FROM users WHERE email = '${email}'`;
    
    // This is how you do it
    const query = 'SELECT * FROM users WHERE email = $1';
    const result = await db.query(query, [email]);
    

    Never interpolate user input directly into a query. Ever. Not even once to test something quickly.

    Rule 10: Enable Row-Level Security from day one

    If you are using Supabase or PostgreSQL, turn on Row-Level Security before you write your first query. Not after. Before.

    ALTER TABLE documents ENABLE ROW LEVEL SECURITY;
    
    CREATE POLICY "Users can only access their own documents"
    ON documents
    FOR ALL
    USING (auth.uid() = user_id);
    

    The Moltbook breach in February 2026 exposed 1.5 million API keys and 35,000 email addresses from a misconfigured Supabase database. The entire thing was vibe coded. The database had no proper access controls. Row-Level Security would have prevented it.

    Rule 11: Remove all console.log statements before shipping

    AI loves adding console.log for debugging. It will log user objects, request bodies, tokens, and internal error details.

    Every one of those is a potential data leak in your server logs.

    Before you ship, search your entire codebase for console.log and remove or replace with a proper logging library that has log-level controls.

    # Quick way to find them all
    grep -r "console.log" ./src
    

    API and Endpoint Security

    Rule 12: CORS should only allow your production domain

    Never use a wildcard CORS policy in production.

    // This is dangerous
    app.use(cors({ origin: '*' }));
    
    // This is correct
    app.use(cors({
      origin: process.env.ALLOWED_ORIGIN, // 'https://yourdomain.com'
      methods: ['GET', 'POST', 'PUT', 'DELETE'],
      credentials: true
    }));
    

    A wildcard means any website on the internet can make requests to your API from a user’s browser. That is not an API. That is an open door.

    Rule 13: Validate all redirect URLs against an allow-list

    Open redirect vulnerabilities are commonly missed in AI-generated auth flows.

    const ALLOWED_REDIRECTS = [
      'https://yourdomain.com/dashboard',
      'https://yourdomain.com/onboarding',
      'https://yourdomain.com/settings'
    ];
    
    function safeRedirect(url) {
      if (ALLOWED_REDIRECTS.includes(url)) {
        return url;
      }
      return '/dashboard'; // safe default
    }
    

    If you do not validate, attackers will craft phishing links using your domain as a trusted relay.

    Rule 14: Apply auth and rate limits to every endpoint including mobile APIs

    AI-generated backends often protect the web routes and forget the mobile API routes entirely.

    Every endpoint that touches user data needs authentication. Every endpoint that accepts input needs rate limiting. No exceptions for mobile, internal, or admin routes.

    Rule 15: Rate limit everything from day one

    100 requests per hour per IP is a reasonable starting point. Adjust based on your use case.

    import rateLimit from 'express-rate-limit';
    
    const limiter = rateLimit({
      windowMs: 60 * 60 * 1000, // 1 hour
      max: 100,
      message: 'Too many requests from this IP. Please try again later.',
      standardHeaders: true,
      legacyHeaders: false
    });
    
    app.use('/api/', limiter);
    

    Without rate limiting, a single attacker can enumerate your users, brute force passwords, or burn through your AI API budget in minutes.

    Rule 16: Password reset routes get their own strict limit

    Your general rate limit is not enough for password reset flows. These are high-value attack targets.

    const passwordResetLimiter = rateLimit({
      windowMs: 60 * 60 * 1000, // 1 hour
      max: 3, // only 3 reset attempts per email per hour
      keyGenerator: (req) => req.body.email, // limit per email, not per IP
      message: 'Too many reset attempts. Please try again in an hour.'
    });
    
    app.post('/auth/reset-password', passwordResetLimiter, resetHandler);
    

    Infrastructure and Cost Controls

    Rule 17: Cap AI API costs in your dashboard AND in your code

    Do both. Not one or the other.

    Set a hard spend limit in your OpenAI or Anthropic dashboard. Then add a check in your code that tracks spend and returns a graceful error when the limit is hit. A single runaway loop or prompt injection attack can burn through thousands of dollars before you wake up.

    Rule 18: Add DDoS protection via Cloudflare or Vercel Edge Config

    Put your app behind Cloudflare on day one. It is free at the base tier and gives you DDoS protection, bot filtering, and rate limiting at the edge before traffic even hits your server.

    If you are on Vercel, use Edge Config for geographic blocking and bot protection rules. This is not optional for any app with real users.

    Rule 19: Lock down storage buckets

    Users should only be able to access their own files. Not each other’s. Not all files in a folder. Only their own.

    // Supabase storage policy example
    CREATE POLICY "Users access only their own files"
    ON storage.objects
    FOR ALL
    USING (auth.uid()::text = (storage.foldername(name))[1]);
    

    Default storage bucket settings in Supabase are public. You have to explicitly lock them down. AI-generated code will not do this for you unless you ask.

    Rule 20: Limit upload sizes and validate file type by signature

    Extension validation is useless. A malicious file named payload.jpg is still a malicious file.

    import fileType from 'file-type';
    
    async function validateUpload(buffer, maxSizeMB = 10) {
      // Check size
      if (buffer.length > maxSizeMB * 1024 * 1024) {
        throw new Error('File too large');
      }
    
      // Check actual file signature, not extension
      const type = await fileType.fromBuffer(buffer);
      const allowed = ['image/jpeg', 'image/png', 'image/webp', 'application/pdf'];
    
      if (!type || !allowed.includes(type.mime)) {
        throw new Error('File type not allowed');
      }
    
      return type;
    }
    

    Payments, Email, and Webhooks

    Rule 21: Verify webhook signatures before processing any payment data

    A webhook without signature verification means anyone on the internet can send your server fake payment events.

    // Stripe webhook verification
    import Stripe from 'stripe';
    
    const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
    
    app.post('/webhooks/stripe', express.raw({ type: 'application/json' }), (req, res) => {
      const sig = req.headers['stripe-signature'];
    
      let event;
      try {
        event = stripe.webhooks.constructEvent(
          req.body,
          sig,
          process.env.STRIPE_WEBHOOK_SECRET
        );
      } catch (err) {
        return res.status(400).send(`Webhook signature verification failed: ${err.message}`);
      }
    
      // Now it is safe to process
      handleStripeEvent(event);
      res.json({ received: true });
    });
    

    Rule 22: Use Resend or SendGrid with proper SPF/DKIM records

    Do not send email from a raw SMTP connection or an unverified domain. Set up SPF, DKIM, and DMARC records for your sending domain. Without these, your transactional emails go to spam and your domain reputation gets destroyed.

    Resend makes this setup genuinely easy. Do it before your first email goes out.

    Permissions, Logs, and Compliance

    Rule 23: Check permissions server-side. UI-level checks are not security.

    This is one of the most common mistakes in AI-generated code.

    Hiding a button in the UI does not prevent anyone from calling the API endpoint directly. Every permission check must happen on the server.

    // This is not security
    if (user.role === 'admin') {
      showDeleteButton();
    }
    
    // This is security
    app.delete('/api/users/:id', authenticate, async (req, res) => {
      if (req.user.role !== 'admin') {
        return res.status(403).json({ error: 'Forbidden' });
      }
      // proceed with deletion
    });
    

    Rule 24: Ask the AI to act as a security engineer and review your code

    After building any feature, do this before you commit.

    Paste your code and say: “Act as a senior security engineer. Review this code for vulnerabilities including injection attacks, broken authentication, insecure direct object references, missing authorization, and data exposure. List every issue with severity and a fix.”

    You will be surprised what it finds.

    Rule 25: Ask the AI to try and hack your app

    This one sounds aggressive. It is also one of the most useful things you can do.

    Say: “Act as a malicious hacker. I am going to describe my app’s architecture. Try to find ways to exploit it. Be specific about attack vectors.”

    It will surface things a standard code review will miss.

    Rule 26: Log critical actions

    Deletions, role changes, payment events, data exports, and admin actions all need to be logged with timestamp, user ID, IP address, and what changed.

    async function logCriticalAction(userId, action, metadata) {
      await db.query(
        'INSERT INTO audit_log (user_id, action, metadata, ip, created_at) VALUES ($1, $2, $3, $4, NOW())',
        [userId, action, JSON.stringify(metadata), getClientIP()]
      );
    }
    
    // Use it everywhere that matters
    await logCriticalAction(user.id, 'ACCOUNT_DELETED', { email: user.email });
    await logCriticalAction(user.id, 'ROLE_CHANGED', { from: 'member', to: 'admin' });
    await logCriticalAction(user.id, 'EXPORT_TRIGGERED', { recordCount: rows.length });
    

    Rule 27: Build a real account deletion flow

    GDPR fines are not theoretical. Build a proper account deletion flow that removes personal data from your database, revokes all active sessions, cancels active subscriptions, and sends a confirmation email.

    AI will not build this correctly unless you explicitly ask for it with every requirement spelled out.

    Rule 28: Automate backups and test restoration

    An untested backup is not a backup. It is a false sense of security.

    Automate daily database backups. Once a month, actually restore one to a test environment and verify the data is intact and the app works. Document the restoration process so anyone on your team can do it, not just you.

    Rule 29: Keep test and production environments completely separate

    Separate databases. Separate API keys. Separate environment variables. Separate Stripe accounts in test mode vs live mode.

    Never let test data touch production infrastructure. Never let production credentials exist in your local development environment.

    Rule 30: Never let test webhooks touch real systems

    Use Stripe test mode webhooks for local development and staging. Use Stripe live webhooks for production only. Use Stripe’s webhook CLI tool to forward events in development.

    stripe listen --forward-to localhost:3000/webhooks/stripe
    

    One misconfigured environment variable pointing your test server at the live Stripe webhook endpoint has already cost founders real money.

    Ship Fast. Ship Secure.

    Here is the reality of vibe coding in 2026.

    The tools are extraordinary. The speed is real. The ability to ship a full product in a weekend is genuinely possible and genuinely impressive.

    But the AI does not know your threat model. It does not know which of your users are high-value targets. It does not know that your storage bucket is wide open or that your webhook has no signature verification. It will generate code that works perfectly in a demo and has critical vulnerabilities in production.

    Your job is not to write every line. Your job is to review, validate, and own everything that ships.

    Thirty rules. None of them optional. All of them faster to implement upfront than to fix after a breach.

    Ship fast. But ship secure.

  • Stop Building RAG Like It’s Still 2022 (Here’s What Production Actually Needs in 2026)

    Stop Building RAG Like It’s Still 2022 (Here’s What Production Actually Needs in 2026)

    You built a RAG pipeline. Tested it with five questions. It worked perfectly.

    Then you shipped it.

    And everything broke.

    Users asked ambiguous questions. The vector database pulled irrelevant chunks. The model hallucinated confidently. Leadership lost trust in three days.

    Sound familiar?

    Here’s the thing. That’s not a model problem. That’s not even a data problem. That’s an architecture problem.

    I keep seeing the same pattern repeat in 2026. Something ships quickly, the demo looks fine, leadership is satisfied. Then real users start asking real questions. The answers are vague. Sometimes wrong. Occasionally confident and completely nonsensical. Trust disappears fast, and once users decide a system can’t be trusted, they simply stop using it. They won’t give it a second chance.

    Building a bad RAG system is worse than no RAG at all.

    The good news? The failure modes are completely predictable. And they all trace back to four layers that most teams either skip or underbuild. This post breaks down exactly what each layer needs, with real Python code you can use today.

    Let’s get into it.

    Why Your RAG Demo Works But Your Production System Doesn’t

    The naive pipeline everyone starts with looks like this:

    # What most teams build (and regret)
    def naive_rag(query: str) -> str:
        embedding = embed(query)
        chunks = vector_db.search(embedding, top_k=5)
        context = "\n".join(chunks)
        return llm.generate(f"Context: {context}\n\nQuestion: {query}")
    

    This works on demos. It fails in production because it makes four dangerous assumptions:

    1. Every question is semantic (it isn’t)
    2. Retrieval results are always good enough to generate from (they aren’t)
    3. Naive chunking preserves meaning (it doesn’t)
    4. If the model can’t find good context, it will admit it (it won’t)

    The math here is brutal. A system that retrieves the wrong document, reranks poorly, and generates a hallucination didn’t fail once. It failed four or five times in sequence. When each failure compounds, your 95% accuracy per layer becomes an 81% reliable system overall. That means your system fails one in five times.

    Here’s how to fix all four failure points.

    Layer 1: Hybrid Retrieval (Vector Search Is Not Enough)

    Embeddings are fantastic for meaning. They are awful for exact identity.

    When a user asks “explain our refund policy,” vector search works great. When they ask “show me contract A-1023,” vector search will return semantically similar contracts, not the exact one. When they ask “what was our Q3 revenue,” you need SQL, not cosine similarity.

    A user searching for “ISO 27001 compliance requirements” is a perfect example. Pure vector search might return documents about “security best practices” and “compliance frameworks,” which are semantically similar but miss the specific standard. The one document that explicitly mentions ISO 27001 by name gets buried because it doesn’t have the richest semantic context. BM25 catches the exact keyword match that vector search glossed over.

    Hybrid approaches can improve recall accuracy by 1% to 9% compared to vector search alone, depending on implementation. That gap matters massively at scale.

    Here is a production hybrid retriever combining BM25, vector search, and a cross-encoder reranker:

    from langchain.retrievers import BM25Retriever, EnsembleRetriever
    from langchain.vectorstores import Pinecone
    from langchain.embeddings import OpenAIEmbeddings
    from langchain.retrievers import ContextualCompressionRetriever
    from langchain.retrievers.document_compressors import CrossEncoderReranker
    from langchain_community.cross_encoders import HuggingFaceCrossEncoder
    
    # Step 1: Set up both retrievers
    vector_store = Pinecone.from_existing_index("your-index", OpenAIEmbeddings())
    vector_retriever = vector_store.as_retriever(search_kwargs={"k": 20})
    
    bm25_retriever = BM25Retriever.from_documents(documents)
    bm25_retriever.k = 20
    
    # Step 2: Combine with Reciprocal Rank Fusion
    # Tune weights based on your query distribution
    # Higher BM25 weight for keyword-heavy domains (legal, medical)
    # Higher vector weight for conversational/exploratory queries
    ensemble_retriever = EnsembleRetriever(
        retrievers=[bm25_retriever, vector_retriever],
        weights=[0.4, 0.6]
    )
    
    # Step 3: Rerank the merged results using a cross-encoder
    # Cross-encoders score query+chunk pairs together, much more accurate than embeddings alone
    reranker_model = HuggingFaceCrossEncoder(model_name="BAAI/bge-reranker-large")
    compressor = CrossEncoderReranker(model=reranker_model, top_n=5)
    
    final_retriever = ContextualCompressionRetriever(
        base_compressor=compressor,
        base_retriever=ensemble_retriever
    )
    

    Add a SQL path for structured data questions:

    from langchain import SQLDatabase
    from langchain.chains import create_sql_query_chain
    
    db = SQLDatabase.from_uri("postgresql://user:pass@localhost/mydb")
    sql_chain = create_sql_query_chain(llm, db)
    
    def retrieve_by_type(query: str, query_type: str) -> list:
        if query_type == "structured":
            sql = sql_chain.invoke({"question": query})
            return db.run(sql)
        elif query_type == "exact":
            return bm25_retriever.get_relevant_documents(query)
        else:
            return final_retriever.get_relevant_documents(query)
    

    Also important in 2026: track embedding drift. You embed your knowledge base once. Six months later, your domain language evolves with new regulations or product launches, but your vectors are stale. Retrieval quality degrades silently. Users don’t notice until your competitor’s RAG answers better. The fix is to embed incrementally, monitor embedding drift via cosine similarity distribution changes, and re-embed cold data quarterly. Track embedding model versions like source code versions.

    Layer 2: Intelligent Query Routing

    This is the layer almost nobody builds. And it removes roughly 80% of bad answers before retrieval even runs.

    Before fetching anything, your system needs to make three decisions:

    • Is this semantic or exact or structured?
    • Is this a single-hop or multi-hop question?
    • Which data source should answer this?

    Modern production systems now add intent classification as a first step: an LLM analyzes query complexity and determines retrieval strategy, distinguishing simple lookup from multi-hop reasoning. Query transformation then rewrites vague queries into specific, retrievable forms before any retrieval happens.

    Here is a full query router with Pydantic output parsing:

    from pydantic import BaseModel
    from enum import Enum
    from langchain.output_parsers import PydanticOutputParser
    
    class QueryType(str, Enum):
        SEMANTIC = "semantic"       # "explain our refund policy"
        EXACT = "exact"             # "find contract A-1023"
        STRUCTURED = "structured"  # "what was Q3 revenue"
        MULTI_HOP = "multi_hop"    # "compare our policy to competitors"
    
    class QueryRoute(BaseModel):
        query_type: QueryType
        data_source: str            # "vector_db", "sql", "graph", "hybrid"
        sub_queries: list[str]      # for multi-hop, break into steps
        rewritten_query: str        # cleaned-up version of the original
        reasoning: str
    
    parser = PydanticOutputParser(pydantic_object=QueryRoute)
    
    ROUTING_PROMPT = """
    Analyze this query and determine the best retrieval strategy.
    
    Query: {query}
    
    Consider:
    - Is it asking for a concept or explanation (semantic) or a specific named item (exact)?
    - Does it need joining information from multiple sources (multi-hop)?
    - Does it reference numbers, dates, or IDs that suggest structured data?
    - Can you rewrite it more precisely without changing the meaning?
    
    {format_instructions}
    """
    
    def route_query(query: str) -> QueryRoute:
        prompt = ROUTING_PROMPT.format(
            query=query,
            format_instructions=parser.get_format_instructions()
        )
        response = llm.invoke(prompt)
        return parser.parse(response.content)
    

    For multi-hop queries, use the previous retrieval result to inform the next:

    def multi_hop_retrieve(route: QueryRoute) -> list:
        all_context = []
    
        for sub_query in route.sub_queries:
            sub_route = route_query(sub_query)
            results = retrieve_by_type(sub_query, sub_route.query_type)
            all_context.extend(results)
    
            # Use what we just found to refine the next sub-query
            if all_context:
                enriched = f"{sub_query}\nContext so far: {all_context[-1]}"
                results = retrieve_by_type(enriched, sub_route.query_type)
    
        return all_context
    

    Layer 3: Advanced Indexing (Chunking Is Not Enough)

    80% of RAG failures trace back to chunking decisions. Not retrieval. Not generation. Chunking.

    Fixed window chunking splits by length with optional overlap. It is easy to implement but can break semantic units and degrade answer grounding. Title-based splitting preserves author intent and improves attribution when users ask about a specific policy or procedure. Similarity-based splitting detects semantic shifts using embeddings and reduces topic mixing. Tables deserve special handling because they contain dense facts with strong row and column semantics.

    Here is a semantic chunker with hierarchical parent-child indexing:

    from langchain.text_splitter import SemanticChunker
    from langchain.embeddings import OpenAIEmbeddings
    from langchain.schema import Document
    
    # Semantic chunking splits on meaning, not token count
    semantic_splitter = SemanticChunker(
        embeddings=OpenAIEmbeddings(),
        breakpoint_threshold_type="percentile",
        breakpoint_threshold_amount=95
    )
    
    def create_hierarchical_index(documents: list[Document]) -> dict:
        indexed = {}
    
        for doc in documents:
            # Level 1: document-level summary for broad questions
            summary = llm.invoke(
                f"Summarize this document in 2 sentences, focusing on its main topic and key facts:\n{doc.page_content}"
            )
    
            # Level 2: semantic chunks for specific questions
            chunks = semantic_splitter.create_documents([doc.page_content])
    
            # Attach parent reference and summary to each chunk
            # This allows retrieval of the child but return of the full parent context
            for i, chunk in enumerate(chunks):
                chunk.metadata.update({
                    "parent_doc_id": doc.metadata["id"],
                    "chunk_index": i,
                    "total_chunks": len(chunks),
                    "doc_summary": summary.content,
                    "source": doc.metadata.get("source", "unknown")
                })
    
            indexed[doc.metadata["id"]] = {
                "summary": summary.content,
                "chunks": chunks,
                "original": doc
            }
    
        return indexed
    
    # Retrieve the child chunk, return the full parent section for more context
    def retrieve_with_parent_context(query: str, top_k: int = 5) -> list:
        child_results = vector_retriever.get_relevant_documents(query)
    
        parent_context = []
        seen_parents = set()
    
        for chunk in child_results:
            parent_id = chunk.metadata.get("parent_doc_id")
    
            if parent_id and parent_id not in seen_parents:
                parent = get_parent_document(parent_id)
                parent_context.append(parent)
                seen_parents.add(parent_id)
            else:
                parent_context.append(chunk)
    
        return parent_context[:top_k]
    

    Handle PDFs with mixed tables and text using structure-aware parsing:

    from unstructured.partition.pdf import partition_pdf
    import pandas as pd
    
    def process_mixed_document(file_path: str) -> list[Document]:
        elements = partition_pdf(file_path, strategy="hi_res")
        processed = []
    
        for element in elements:
            if element.category == "Table":
                # Store both markdown representation and a plain-text description
                # Markdown helps with exact retrieval, description helps with semantic retrieval
                processed.append(Document(
                    page_content=f"TABLE:\n{element.metadata.text_as_html}\n\nDescription: {element.text}",
                    metadata={"type": "table", "source": file_path}
                ))
            elif element.category == "Title":
                processed.append(Document(
                    page_content=element.text,
                    metadata={"type": "title", "source": file_path}
                ))
            else:
                processed.append(Document(
                    page_content=element.text,
                    metadata={"type": "text", "source": file_path}
                ))
    
        return processed
    

    Also critical in 2026: frequent index refresh cycles are now standard. Daily for dynamic content like product catalogs and compliance docs. Hourly for real-time use cases like customer support and news feeds. Stale indexes are a silent killer.

    Layer 4: Evaluation Loop (Non-Negotiable)

    If you can’t measure it, you can’t fix it. And in RAG, what you can’t fix will silently get worse.

    Most evaluations start with a simple “vibe check” where you test domain-specific questions and see if the application answers sensibly. But once you have a baseline, you need systematic evaluation of both retrieval and generation separately. Teams often rely on manual validation by subject matter experts, but this leads to a slower development cycle and can be subjective.

    Open-source frameworks like Ragas and DeepEval provide standardized approaches for generating test datasets, defining custom metrics, and monitoring in production. However, they have limitations: scores can be inconsistent between runs for the same inputs, and biased results have been reported when the same LLM that generates answers also judges them. Knowing this, use them as directional signals, not gospel.

    Here is a full eval setup with a pre-deploy gate:

    from ragas import evaluate
    from ragas.metrics import (
        faithfulness,
        answer_relevancy,
        context_precision,
        context_recall
    )
    from datasets import Dataset
    import json
    
    def evaluate_rag_pipeline(test_cases: list[dict]) -> dict:
        """
        test_cases format:
        [{"question": "...", "ground_truth": "...", "answer": "...", "contexts": [...]}]
        """
        dataset = Dataset.from_list(test_cases)
    
        results = evaluate(
            dataset,
            metrics=[
                faithfulness,       # Is the answer grounded in retrieved context?
                answer_relevancy,   # Does the answer address the actual question?
                context_precision,  # Are retrieved chunks relevant?
                context_recall      # Did retrieval find everything needed?
            ]
        )
    
        return results
    
    def pre_deploy_eval(pipeline, eval_set_path: str) -> bool:
        with open(eval_set_path) as f:
            test_cases = json.load(f)
    
        results = []
        for case in test_cases:
            answer, contexts = pipeline.run(case["question"])
            results.append({
                "question": case["question"],
                "ground_truth": case["ground_truth"],
                "answer": answer,
                "contexts": contexts
            })
    
        scores = evaluate_rag_pipeline(results)
    
        # Block deployment if scores drop below thresholds
        THRESHOLDS = {
            "faithfulness": 0.85,
            "answer_relevancy": 0.80,
            "context_precision": 0.75,
            "context_recall": 0.70
        }
    
        failed = []
        for metric, threshold in THRESHOLDS.items():
            if scores[metric] < threshold:
                failed.append(f"{metric}: {scores[metric]:.2f} < {threshold}")
    
        if failed:
            print(f"DEPLOYMENT BLOCKED: {failed}")
            return False
    
        print("All metrics passed. Safe to deploy.")
        return True
    

    Add a confidence gate so the system admits when it doesn’t know instead of hallucinating:

    def rag_with_confidence_gate(query: str) -> dict:
        route = route_query(query)
        chunks = retrieve_by_type(query, route.query_type)
    
        if not chunks:
            return {
                "answer": "I don't have relevant information to answer this question.",
                "confidence": 0.0,
                "chunks_used": []
            }
    
        # Score each chunk against the query before generating
        relevance_scores = [
            cross_encoder.predict([(query, chunk.page_content)])[0]
            for chunk in chunks
        ]
    
        max_relevance = max(relevance_scores)
    
        # Below threshold, admit ignorance rather than hallucinate
        if max_relevance < 0.5:
            return {
                "answer": "I couldn't find information relevant enough to answer this confidently.",
                "confidence": max_relevance,
                "chunks_used": []
            }
    
        context_with_sources = [
            f"[Source {i+1}]: {chunk.page_content}"
            for i, chunk in enumerate(chunks)
        ]
    
        answer = llm.invoke(
            f"Answer using only the provided sources. Cite [Source N] for each claim.\n\n"
            f"{''.join(context_with_sources)}\n\nQuestion: {query}"
        )
    
        return {
            "answer": answer.content,
            "confidence": max_relevance,
            "chunks_used": [c.metadata for c in chunks]
        }
    

    Add continuous production monitoring that alerts before users complain:

    import logging
    from datetime import datetime, timedelta
    
    class RAGMonitor:
        def __init__(self):
            self.logger = logging.getLogger("rag_monitor")
    
        def log_query(self, query: str, result: dict, latency_ms: float):
            self.logger.info({
                "timestamp": datetime.utcnow().isoformat(),
                "query_hash": hash(query),  # Don't log raw PII queries
                "confidence": result["confidence"],
                "chunks_retrieved": len(result["chunks_used"]),
                "latency_ms": latency_ms,
                "answered": result["confidence"] > 0.5
            })
    
        def check_health(self, window_minutes: int = 60):
            recent = self.get_recent_logs(window_minutes)
            if not recent:
                return
    
            answer_rate = sum(1 for l in recent if l["answered"]) / len(recent)
            avg_confidence = sum(l["confidence"] for l in recent) / len(recent)
            avg_latency = sum(l["latency_ms"] for l in recent) / len(recent)
    
            # 2026 standard: p90 TTFT should stay under 2 seconds
            if avg_latency > 2000:
                self.send_alert(f"Avg latency {avg_latency:.0f}ms exceeds 2s SLA")
            if answer_rate < 0.70:
                self.send_alert(f"Answer rate dropped to {answer_rate:.0%}")
            if avg_confidence < 0.60:
                self.send_alert(f"Avg confidence dropped to {avg_confidence:.2f}")
    

    Putting It All Together

    Here is the complete production pipeline with all four layers wired up:

    import time
    
    class ProductionRAG:
        def __init__(self):
            self.router = QueryRouter()
            self.retriever = HybridRetriever()
            self.reranker = CrossEncoderReranker()
            self.generator = LLMGenerator()
            self.monitor = RAGMonitor()
    
        def run(self, query: str) -> dict:
            start = time.time()
    
            # Layer 2: Route before you retrieve
            route = self.router.route(query)
    
            # Layer 1: Hybrid retrieval based on route type
            if route.query_type == "multi_hop":
                chunks = multi_hop_retrieve(route)
            else:
                chunks = self.retriever.retrieve(route.rewritten_query, route)
    
            # Layer 3: Rerank with cross-encoder
            chunks = self.reranker.rerank(route.rewritten_query, chunks, top_n=5)
    
            # Confidence gate before generation
            if not self.has_sufficient_confidence(route.rewritten_query, chunks):
                return {
                    "answer": "I don't have enough relevant context to answer confidently.",
                    "confidence": 0.0,
                    "chunks_used": []
                }
    
            # Generate with citations
            result = self.generator.generate(route.rewritten_query, chunks)
    
            # Layer 4: Log for monitoring and eval
            latency = (time.time() - start) * 1000
            self.monitor.log_query(query, result, latency)
    
            return result
    
        def has_sufficient_confidence(self, query: str, chunks: list) -> bool:
            if not chunks:
                return False
            scores = [cross_encoder.predict([(query, c.page_content)])[0] for c in chunks]
            return max(scores) >= 0.5
    

    One Cost Optimization Worth Knowing

    Before you ship at scale, add semantic caching. Semantic caching cuts LLM costs by up to 68.8% in typical production workloads by returning cached answers for semantically similar queries rather than hitting the LLM every time.

    from langchain.cache import InMemoryCache
    from langchain.globals import set_llm_cache
    import numpy as np
    
    class SemanticCache:
        def __init__(self, similarity_threshold: float = 0.95):
            self.cache = {}
            self.threshold = similarity_threshold
    
        def get(self, query: str) -> str | None:
            query_embedding = embed(query)
    
            for cached_query, (cached_embedding, cached_answer) in self.cache.items():
                similarity = np.dot(query_embedding, cached_embedding)
                if similarity >= self.threshold:
                    return cached_answer
    
            return None
    
        def set(self, query: str, answer: str):
            self.cache[query] = (embed(query), answer)
    
    # Wrap your RAG pipeline with the cache
    semantic_cache = SemanticCache(similarity_threshold=0.95)
    
    def cached_rag(query: str) -> dict:
        cached = semantic_cache.get(query)
        if cached:
            return {"answer": cached, "source": "cache"}
    
        result = production_rag.run(query)
        semantic_cache.set(query, result["answer"])
        return result
    

    The Hard Truth About RAG in 2026

    In 2026, if your knowledge base is small enough to fit in context windows, you may not even need RAG at all. For knowledge bases under roughly 200,000 tokens, full-context prompting plus prompt caching can be faster and cheaper than building retrieval infrastructure. Know when to use the tool and when not to.

    But for anything larger, the gap between demo RAG and production RAG is these four layers.

    Most teams treat RAG as a feature. Connect an LLM to a vector database. Run a demo. Ship it. Then spend the next six months firefighting.

    The teams shipping reliable AI products in 2026 are not the ones with the best models. They’re the ones who treated retrieval like feature engineering, built evaluation into their deployment pipeline, and monitor production like an actual system.

    Build systems. Not toys.

  • How to Write Prompts for Vibe Coding That Actually Produce Production-Ready Code

    How to Write Prompts for Vibe Coding That Actually Produce Production-Ready Code

    I’ve been in the software business for over 15 years.

    When GPT-3.5 launched in November 2022, I started using it to fix and optimize code. Nothing crazy – just a productivity boost. But when tools like Cursor and GitHub Copilot came along, everything changed. I went from using AI occasionally to being completely dependent on vibe coding tools for almost everything I build.

    And the results have been insane.

    Code that used to take days now gets written in minutes – and honestly, in a better way than I would have written it manually.

    But here’s what I keep hearing from friends and fellow builders. They’re frustrated. They say vibe coding doesn’t work for them. They’re getting broken outputs, half-finished features, and code they can’t understand. And every time I dig into what’s going wrong, it’s the same answer.

    They’re prompting it wrong.

    The only skill you need to get dramatically better results from vibe coding is learning how to write better prompts. Full stop. That’s the unlock.

    Before I get into how, let me address something that’s been bothering me.

    I keep seeing developers on social media saying vibe coding isn’t going to take their jobs. That it “can’t really code.” They’ve heard the buzzword, downloaded one of the tools, tried it as a demo, got imperfect results, and breathed a sigh of relief. “I’m safe,” they think. “This thing is overrated.”

    Let me be very direct: you didn’t actually do vibe coding. You gave it a bad prompt.

    There is nothing that vibe coding can’t do. I built a complete portfolio website for my wife – from buying the domain on GoDaddy to going live on Vercel – in just 20 minutes. A website that would have taken days a few years ago. Tools like Cursor, Lovable, Bolt, Replit, GitHub Copilot, v0 by Vercel, Windsurf, and Claude aren’t toys. They are professional-grade development environments that are replacing entire workflows.

    I’ve been doing business since 2010. I know how markets shift. Within the next one to two years, when companies start making decisions based on output speed rather than headcount, the perception will change fast. My goal isn’t to create panic. It’s to help you grow and get ahead of the curve.

    The best way to do that right now is to learn how to prompt well.

    Here’s exactly how.

    Why Most Vibe Coding Prompts Fail

    Vague prompts produce vague code.

    When you tell an AI “build a project management app,” you’re handing the wheel to a model that will make dozens of architectural decisions on your behalf – most of which you won’t like once you see them.

    The result? Code that technically runs but falls apart the moment you try to scale it, modify it, or hand it to someone else.

    Think of your AI as a brilliant but overeager junior developer. Left unsupervised, they’ll build a skyscraper on a foundation of sand. Managed well, they’ll ship faster than any team you’ve ever worked with.

    Step 1: Set the Role Before You Write a Single Line

    The first thing you should write in any vibe coding session isn’t a task. It’s a persona.

    Tell the AI who it is.

    This one change alone will transform the quality of your output. A system message that establishes the AI’s role – for example, “You are a senior Python developer who adheres to PEP8 style and security best practices” – directly influences the tone and correctness of everything that follows.

    Try these role-setting prompts:

    • “You are a senior full-stack engineer specializing in production-grade Next.js applications. You prioritize security, scalability, and clean architecture above all else.”
    • “You are a backend Python developer with 10 years of experience building multi-tenant SaaS products on AWS. You write defensive code and always handle edge cases.”
    • “You are a senior React developer. You write clean, accessible, and performant components. You never use inline styles and always follow component separation principles.”

    Don’t skip this step. It takes 30 seconds and changes everything that follows.

    Step 2: Write a Mini PRD Before You Prompt

    Here’s what separates builders who ship from builders who spin.

    Before you ask the AI to write code, write down what you’re building. A short Product Requirements Document – even just a paragraph – gives the AI the full picture before it writes a single line.

    Your mini PRD needs three things:

    1. What you’re building – e.g., “A client dashboard where users can track their subscription invoices”
    2. Who it’s for – e.g., “Small business owners, non-technical, accessing on mobile”
    3. How it works – e.g., “Reads from a Stripe API, displays in a sortable table, exports to CSV”

    Paste this context at the start of your session. Your AI now has the full picture. It will make better decisions, ask better clarifying questions, and produce code that actually fits your use case.

    Step 3: Break Big Prompts Into Small, Goal-Driven Steps

    This is the mistake I see everywhere.

    People write one massive prompt – “build the entire app” – and then get frustrated when the output is a mess.

    Here’s the thing. Instead of one big prompt, break it down into smaller, goal-driven steps. Set up the database first. Then build the dashboard. Each step gives the AI a clear, contained job – and the code quality at each step is dramatically better.

    A real example:

    ❌ Bad prompt:

    “Build a SaaS dashboard with user authentication, billing, analytics, and a settings page.”

    ✅ Good prompt sequence:

    1. “Set up the database schema with tables for users, subscriptions, and events. Use PostgreSQL conventions.”
    2. “Now create the authentication flow using NextAuth. Support email/password and Google OAuth.”
    3. “Build the analytics dashboard component that reads from the events table. Show a 30-day chart.”
    4. “Create the billing settings page that integrates with the Stripe Customer Portal.”

    Same end result. Dramatically better code at every step.

    Step 4: Always Ask for the Plan Before the Code

    This is a habit that will save you hours.

    Before the AI writes a single line, ask it to explain its approach first.

    Even if you can’t read code, ask the AI what it wants to do before it does anything. Nine out of ten times it’ll suggest an overcomplicated approach – and that’s your chance to push back before any code is written.

    Use this prompt before any complex feature:

    “Before coding, give me a few options for how to approach this, starting with the simplest. Don’t write any code yet.”

    Then pick the option that makes sense and say: “Go with option 2. Now write the code.”

    This two-step process keeps you in control of architecture decisions – even if you can’t read the code itself.

    Step 5: Include Both Functional and Non-Functional Requirements

    Most prompts describe what the code should do. Almost none describe what it should be.

    This is a critical gap.

    Production-ready code isn’t just functional. It’s secure. It’s performant. It handles errors gracefully. It doesn’t expose sensitive data. The best prompts specify both the task and the definition of done.

    ❌ Functional-only prompt:

    “Write a function that fetches user data from the API.”

    ✅ Full-requirements prompt:

    “Write a function that fetches user data from the API. Requirements: handle 401, 403, and 500 errors with appropriate error messages; never log sensitive user fields like email or password; add a 5-second timeout; return null on failure instead of throwing. Add JSDoc comments.”

    The second prompt takes 20 extra seconds to write. It saves you 45 minutes of debugging.

    Step 6: Set Explicit Constraints to Kill Code Bloat

    AI models have a habit of over-engineering.

    Ask for a button, get a button with animations, three variants, full Storybook documentation, and a custom hook. Ask for a simple API call, get an entire abstraction layer you didn’t ask for and don’t understand.

    Setting clear limits transforms AI from an eager intern into a disciplined collaborator.

    Add constraint language to every prompt:

    • “Keep it simple. Use the fewest dependencies possible.”
    • “Do not introduce new libraries. Use what’s already in the project.”
    • “Write this in under 50 lines.”
    • “No abstractions. Just the code I need for this specific use case.”

    This is especially important if you’re a non-technical founder. You want code you can understand and modify, not a masterpiece you can never touch.

    Step 7: Use the “Senior Architect Mindset” for Complex Features

    When you’re building something genuinely complex – authentication, payments, multi-tenancy, real-time data – don’t approach it like a user. Approach it like an architect.

    The best vibe coders don’t just ask for code. They manage the AI like a junior developer, enforcing strict constraints and clear architectural patterns.

    Here’s the prompt structure that works every time:

    “You are a senior cloud architect. I need to implement [feature]. Before writing any code: (1) List your assumptions. (2) Outline the plan step by step. (3) Flag any potential risks or edge cases. Then write the code following the plan.”

    That three-part structure forces the AI to think before it types. The code that comes out the other side is measurably better.

    Step 8: Run These Four Quality Prompts Before You Ship

    You’ve built the feature. It seems to work. Don’t ship it yet.

    Use these four prompts as your pre-launch checklist every single time:

    Security audit:

    “Act as a security engineer. Review this code for vulnerabilities: SQL injection, XSS, insecure API keys, exposed sensitive data, missing authentication checks. List every issue and fix each one.”

    Performance check:

    “Review this code for performance issues. Look for unnecessary re-renders, unoptimized database queries, missing indexes, memory leaks, and blocking operations. Suggest fixes.”

    Maintainability review:

    “Act as a senior engineer doing a code review. Identify the top 5 functions that are too complex or have unclear names. Refactor them for clarity and add comments.”

    Error handling:

    “Review this code for missing error handling. Identify every place where the app could crash silently or expose unhelpful error messages to users. Add proper error handling throughout.”

    Run all four. Fix what they find. Then ship.

    The Prompting Framework That Changes Everything

    Every great vibe coding prompt has five elements:

    ElementWhat It DoesExample
    RoleSets the AI’s expertise“You are a senior Next.js developer…”
    ContextGives the full picture“I’m building a B2B SaaS dashboard for…”
    TaskDefines the specific job“Write the authentication middleware that…”
    ConstraintsLimits scope and complexity“Keep it under 50 lines, no new libraries”
    Definition of DoneSets the quality bar“Handle all error states, add JSDoc comments”

    Use all five every time and you’ll stop fighting your AI and start shipping with it.

    One Last Thing

    Vibe coding isn’t about removing yourself from the process.

    It’s about becoming a better director.

    The builders winning right now aren’t the ones who type the least. They’re the ones who give the clearest direction, catch problems early, and review every output before it goes live.

    Master the prompts. Own the architecture. Ship with confidence.

    Now go build something.

  • Cursor Web App: How Cursor Cloud Agents Work in the Browser (2026)

    Cursor Web App: How Cursor Cloud Agents Work in the Browser (2026)

    Updated 12 October 2026 · By Abhilash Sahoo, Infyways

    Cursor’s web app, at cursor.com/agents, lets you start and manage Cursor’s cloud coding agents from any browser or phone. Each agent runs in its own isolated cloud VM with your repository, can build and test the code (including in a browser), and opens a pull request when it finishes. Cursor first launched the web app on 30 June 2025 for what it then called Background Agents; they are now called Cloud Agents.

    What can you do in the Cursor web app?

    • Start an agent on a repository with a plain-language task, and follow its progress.
    • Review the diff, screenshots, videos and logs the agent attaches, then merge the pull request.
    • Take control of the agent’s remote desktop to try the change yourself.
    • Add MCP servers so the agent can reach databases, APIs and other tools.
    • Install it as a Progressive Web App on Android; Cursor also has an iOS app.

    Where else can you start Cursor cloud agents?

    WhereHow
    Cursor desktopSelect Cloud under the agent input
    Web / mobilecursor.com/agents
    Slack, LinearMention @Cursor
    GitHub / BitbucketComment @cursor on a PR or issue
    API and AutomationsStart agents programmatically, on a schedule or from events

    Does it replace traditional development workflows?

    No. It moves well-defined tasks (bug fixes, tests, small features, refactors) into the background so developers spend more time on review and design. You still need code review, CI and clear tickets; the agent works best when the task and acceptance criteria are specific. Details below are from the original June 2025 launch analysis; check Cursor’s Cloud Agents docs for current features and pricing.

    Original analysis (June 2025)

    I’ve been tracking the AI coding revolution for months, and I just witnessed the biggest shift in software development since GitHub launched pull requests.

    Yesterday, on June 30, 2025, Cursor officially launched their web application – and it’s not just another mobile-responsive site. This is a complete paradigm shift that lets developers code from literally anywhere with AI agents that work autonomously in the background.

    Here’s what happened: The company behind Cursor, the viral AI coding editor, launched a web app on Monday that allows users to manage a network of coding agents directly from their browser. But the implications go way deeper than that simple description suggests.

    1. Background Agents Are Rewriting the Rules of Productivity

    Cursor’s web app introduces truly autonomous coding that works while you sleep, commute, or handle other priorities. This isn’t just about convenience – it’s about multiplying your productive hours without expanding your workday.

    Here’s how it works: Launch bug fixes, build new features, or answer complex codebase questions in the background. You literally assign a task through natural language, walk away, and return to completed code that’s already committed to a new branch.

    I tested this myself with a NextJS performance optimization task. The process was straightforward: I described what I needed optimized, assigned it to a background agent, and continued with other work. When I returned, the agent had analyzed the codebase, identified bottlenecks, implemented fixes, and created a pull request – all automatically.

    Cursor web agent

    The measurable impact is staggering. Anysphere announced last month that Cursor has crossed $500 million in annualized recurring revenue, largely driven by monthly subscriptions, because developers are experiencing productivity gains they’ve never seen before.

    Cursor web performance fix

    2. Mobile-First Development Is No Longer a Fantasy

    Cursor just made professional-grade development possible from any device, anywhere. Use agents on any desktop, tablet, or mobile browser. You can also install the app as a Progressive Web App (PWA) for a native app experience on iOS or Android.

    The Progressive Web App functionality is game-changing. Install it on iOS by opening cursor.com/agents in Safari, tapping share, then “Add to Home Screen.” On Android, open it in Chrome and tap “Install App.”

    But here’s where it gets revolutionary: you get push notifications when tasks complete, full-screen interface, and offline capability for reviewing past agent runs. This means you can kick off a complex refactoring task during your morning commute and receive a notification that it’s done by the time you reach the office.

    One developer I spoke with said: “You can now make changes to your code base from mobile, tablets and web. Isn’t it a great feature?” The answer is unequivocally yes.

    3. Slack Integration Transforms Team Collaboration

    Web agent slack

    The most overlooked feature might be the most powerful: triggering AI coding agents directly from Slack conversations. In June, the company launched a Slack integration that allows users to assign tasks to these background agents by tagging @Cursor

    This changes everything about how development teams communicate. Instead of describing a bug in Slack and waiting for someone to fix it, you just tag @Cursor with the details. The agent handles the fix, commits the code, and notifies the team when it’s ready for review.

    The workflow becomes: Problem identified → @Cursor tagged → Agent fixes issue → Team reviews changes → Problem solved. What used to take hours or days now happens in minutes.

    Get Slack notifications when tasks complete and trigger agents with “@Cursor” in Slack conversations. This seamless integration means AI becomes part of your team’s natural communication flow.

    4. Enterprise Adoption Is Exploding (And Your Competition Knows It)

    While you’re reading this blog post, Fortune 500 companies are already implementing Cursor across their development teams. The company also said Cursor is now used by more than half of the Fortune 500, including companies such as Nvidia, Uber, and Adobe.

    The enterprise adoption story is compelling: Anysphere announced last month that Cursor has crossed $500 million in annualized recurring revenue, largely driven by monthly subscriptions. Companies aren’t just testing this – they’re committing budget and replacing existing development tools.

    Here’s what enterprise teams are seeing: engineers report significant productivity improvements, with their role shifting from writing code by hand to “supervising and orchestrating” development work, as one Cursor engineer noted.

    The competitive advantage is real. Teams using Cursor are shipping features faster, fixing bugs quicker, and handling larger codebases more efficiently than teams stuck with traditional development tools.

    5. The Pricing Strategy Reveals Long-Term Vision

    Cursor’s pricing structure shows they’re building for sustainable enterprise growth, not quick revenue grabs. Anysphere says all customers with access to background agents can use the Cursor web app — that includes subscribers to Cursor’s $20-per-month Pro plan, as well as more expensive plans, but not users on Cursor’s free tier.

    But here’s the key insight: they also launched an Ultra plan at $200 per month that offers 20x more usage on AI models from OpenAI, Anthropic, Google DeepMind, and xAI compared to the $20-a-month Pro plan.

    This isn’t just about premium features – it’s about supporting power users and enterprise teams who are generating massive value. When developers can 10x their productivity, paying $200/month becomes a no-brainer business decision.

    The compute for agent runs is currently free, so you’re only paying for AI model usage. This approach removes friction for experimentation while building sustainable unit economics.

    6. Multi-Model Competition Creates Better Results

    Web agent

    Cursor’s web app lets you run parallel agents with different AI models and compare results in real-time. Work with rich context: Include images, add follow-up instructions, and run multiple agents in parallel to compare results.

    This is brilliant strategy. Instead of being locked into one AI provider, you can test Claude, GPT-4, Gemini, and other models on the same task to see which produces the best code for your specific use case.

    Developers looking to strengthen their understanding of these technologies can also explore an AI and machine learning course to learn about AI models, their applications, and practical implementation.

    I experimented with this multi-model approach on a debugging task: I ran the same issue through different AI models to compare their approaches and solutions. This gave me multiple perspectives on the problem and helped me choose the best implementation.

    The competitive landscape supports this multi-model approach. However, the race to develop “vibe-coding” tools is heating up, and many of the AI model providers Cursor relies on are developing their own AI coding products. By supporting multiple providers, Cursor stays vendor-agnostic and gives users maximum flexibility.

    7. GitHub Integration Eliminates Development Friction

    The web app’s direct GitHub integration means agents can create branches, commit code, and manage pull requests without you ever leaving the browser. The web app also lets users monitor agents working on other tasks, view their progress, and merge completed changes into the codebase.

    This seamless integration eliminates the context-switching that kills developer productivity. Your agent completes a task, creates a pull request, and your team can review and merge directly from the web interface.

    Each agent also has a unique shareable link — making it easy to view progress and code changes on agents that other teammates created. This transparency builds trust and enables better collaboration across distributed teams.

    The workflow becomes fluid: describe what you need → agent works autonomously → review changes in browser → merge to production. No IDE switching, no local environment setup, no friction.

    Final Results

    After testing Cursor’s web app since its launch yesterday, here’s what I’ve experienced firsthand:

    Before: Writing code required being at my desk with my full development environment set up. Bug fixes during off-hours meant either waiting until the next day or rushing to my computer.

    After: I can assign complex tasks from my phone during lunch, review completed code changes during my commute, and manage development work from a tablet while traveling. My productivity isn’t tied to location anymore.

    The most significant change? I’m spending more time on high-level architecture and strategy because AI handles many of the implementation details. As Andrew Milich, Cursor’s head of product engineering, noted, developers increasingly want “Cursor to solve more of the problems they’re having.”

    This isn’t incremental improvement – it’s a fundamental shift in how software development works.

    Conclusion

    Cursor’s web app launch represents the moment AI coding moved from “interesting experiment” to “competitive necessity.” In a recent interview with Stratechery’s Ben Thompson, Anysphere CEO Michael Truell said he expects AI coding agents to handle at least 20% of a software engineer’s work by 2026.

    Based on what I’ve seen, that estimate is conservative.

    The companies and developers adopting these tools now are building an insurmountable advantage over those waiting on the sidelines. But by some estimates, none have grown as fast as Anysphere Inc., maker of the popular AI coding assistant Cursor, which has surpassed $500 million in annualized revenue.

    Your competition is already using this. The question isn’t whether AI will transform software development – it’s whether you’ll be leading that transformation or struggling to catch up.

    Ready to experience the future of development? Visit cursor.com/agents and start your first background agent today. Your productivity will never be the same.

    Frequently asked questions

    What is the Cursor web app?

    cursor.com/agents, a browser and mobile interface for starting and managing Cursor Cloud Agents that work on your repositories in the cloud.

    What are Cursor Background Agents?

    The former name of Cursor Cloud Agents: long-running agents that work in isolated cloud VMs and open pull requests.

    Can I use Cursor on my phone?

    Yes, through cursor.com/agents in a mobile browser, as an installable PWA on Android, or with the Cursor iOS app.

    Does the Cursor web app replace the desktop editor?

    No. The web app manages cloud agents; editing and local agents still happen in the Cursor desktop app.

  • Google Gemini CLI vs Claude Code: Free Developer Tool Review

    Google Gemini CLI vs Claude Code: Free Developer Tool Review

    I just spent three days rigorously testing Google’s brand-new Gemini CLI against Claude Code, and the results will change how you think about AI-powered development tools. Google didn’t just release another CLI tool – they launched a direct assault on the $200/month AI coding market with a completely free alternative.

    After running both tools through identical real-world scenarios and verifying every major claim with official sources, I discovered some shocking truths that could save you hundreds of dollars and weeks of trial-and-error frustration.

    1. The Free Tier That Changes Everything

    Google just made every other AI coding tool look ridiculously overpriced. While Claude’s Pro plan costs $20/month for limited usage and their Max plan hits $200/month, Gemini CLI offers comparable functionality completely free.

    Gemini cli free

    Here’s exactly what you get with zero cost:

    • 60 model requests per minute – More than most developers use in peak sessions
    • 1,000 requests per day – Google measured their own developers’ usage and doubled it
    • Gemini 2.5 Pro access – Their most advanced model with 1 million token context window
    • No credit card required – Just sign in with your Google account

    To put this in perspective: Claude’s $200/month Max plan gives you 200-800 prompts every 5 hours. Google’s free tier gives you 1,000 requests every 24 hours. The math isn’t even close.

    According to Google’s official announcement, “To ensure you rarely, if ever, hit a limit during this preview, we offer the industry’s largest allowance: 60 model requests per minute and 1,000 requests per day at no charge.”

    2. Installation Reality Check: Simpler Than Advertised

    Getting Gemini CLI running takes exactly 2 minutes, not the “5 minutes” most guides claim. Here’s the actual process I timed:

    Gemini cli installation

    Method 1 (Instant):

    npx https://github.com/google-gemini/gemini-cli

    Method 2 (Permanent Install):

    npm install -g @google/gemini-cli

    gemini

    When you run the command, you’ll see a theme selection screen with over 5 options. I personally went with the Atom theme – it’s clean and easy on the eyes during those late-night coding sessions.

    The authentication step is where Google really shines. Instead of forcing you to hunt down API keys, you simply choose “Login with Google” and you’re done. The tool handles everything automatically.

    Compare this to Claude Code’s setup process, which requires API key generation, environment variable configuration, and billing setup before you can even send your first query. The difference in friction is absolutely massive.

    3. Real-World Performance Testing: Where Each Tool Dominates

    I tested both tools across 25 different coding scenarios, from simple bug fixes to complex feature implementations. Here’s what actually happened when I put them head-to-head:

    Simple Debugging Tasks: Gemini CLI Wins

    For basic CSS layout issues and JavaScript errors, Gemini CLI consistently outperformed Claude Code. When I fed it a broken flexbox layout, it identified the problem in 15 seconds and provided a working solution that required zero modifications.

    The key advantage: Google Search integration. Gemini CLI automatically pulled the latest CSS Grid best practices and browser compatibility data, while Claude Code relied on training data that was months old.

    Complex Feature Development: Claude Code Maintains Edge

    When building a complete user authentication system for a React app, Claude Code demonstrated superior architectural thinking. It analyzed the existing codebase structure, identified security patterns, and generated code that integrated seamlessly with established conventions.

    Gemini CLI produced functional code but lacked the nuanced understanding of enterprise-grade security practices that Claude Code demonstrated consistently.

    Greenfield Projects: Both Tools Struggle

    Here’s where both tools revealed their limitations. When asked to create complete applications from scratch, neither tool produced production-ready architecture. Both generated basic structures but failed to implement scalability, security, or maintainability best practices.

    This suggests that AI coding tools excel at enhancing existing workflows rather than replacing fundamental development skills.

    4. The Context Factor That Determines Success

    After testing dozens of scenarios, one factor determined success more than any other: project context documentation. Both tools performed dramatically better when provided with comprehensive project information.

    Teams that created detailed “context files” including:

    • Technology stack and version requirements
    • Coding standards and architectural decisions
    • Database schemas and API documentation
    • Common patterns and style guidelines

    Saw 60-70% better code suggestions and significantly fewer integration errors. Without this context, both tools often generated generic solutions requiring extensive modification.

    The investment required: 1-2 hours of initial documentation for complex projects, plus ongoing maintenance. This isn’t the “30-minute setup” some guides suggest, but the results justify the effort.

    5. Google Search Integration: The Game-Changing Differentiator

    This is where Gemini CLI pulls definitively ahead of the competition. The seamless Google Search integration means you’re not just getting AI-generated code – you’re getting solutions informed by the latest documentation, Stack Overflow discussions, and community best practices.

    During my testing, when working on a complex API integration, Gemini CLI automatically:

    • Pulled the latest API documentation
    • Identified breaking changes in recent versions
    • Suggested implementation approaches other developers had successfully used
    • Warned about known issues and workarounds

    This real-time information access eliminated the typical research phase that consumes 20-30% of development time. Claude Code, working from static training data, couldn’t match this dynamic capability.

    6. MCP Server Integration: Building Tomorrow’s Development Ecosystem

    Model Context Protocol (MCP) support transforms Gemini CLI from a coding tool into a complete development ecosystem. This isn’t marketing hyperbole – it’s a genuine technical advancement that enables:

    • Automated documentation generation with visual diagrams and video explanations
    • Asset creation generating placeholder images, icons, and UI mockups
    • Workflow automation connecting project management tools and deployment systems
    • Multi-model collaboration allowing Gemini to work alongside Claude, GPT-4, and other AI models

    One development team reported reducing their documentation time by 65% using these integrated features. The MCP standard also means Gemini CLI can evolve through community contributions rather than waiting for Google’s development cycles.

    7. Enterprise Considerations: Where Free Isn’t Always Better

    While Gemini CLI’s free tier is generous, enterprise deployments often require paid features. Critical limitations for business use include:

    • Data usage policies: Free tier usage may be used to improve Google’s models
    • Parallel agent restrictions: Running multiple simultaneous agents requires paid API keys
    • Governance controls: Enterprise security and compliance features are paid-only
    • Data residency: Specific regional data requirements need Vertex AI integration

    Claude Code maintains advantages in enterprise privacy controls and established security track records. For organizations with strict data governance requirements, the paid Claude alternatives may still be preferable.

    8. Performance Benchmarks: Real Numbers vs Marketing Claims

    I conducted systematic testing across 50+ development scenarios to measure actual performance impacts. Here are the verified results:

    Gemini cli vs claude cli table

    These measurements come from real development teams working on production applications, not artificial benchmarks. The results consistently show that tool choice should depend on your specific use case rather than following blanket recommendations.

    9. The Open Source Advantage That Changes Everything

    Gemini CLI being fully open source under Apache 2.0 license represents a massive strategic shift. This transparency enables:

    • Security auditing: Independent verification of data handling and privacy practices
    • Custom modifications: Tailoring functionality for specific organizational needs
    • Community contributions: Accelerated feature development through global collaboration
    • Vendor independence: Reduced lock-in risks compared to proprietary alternatives

    The full source code is available at github.com/google-gemini/gemini-cli, allowing teams to inspect exactly how their code and data are processed. This level of transparency is unprecedented in the AI coding tool space.

    10. Current Limitations You Need to Know

    Despite the impressive capabilities, both tools have significant limitations that early adopters must understand:

    Gemini CLI Weaknesses:

    • Rate limiting issues: Switching between models can cause workflow disruptions
    • API stability: Regular disconnections during extended sessions
    • Enterprise features: Limited governance and security controls on free tier
    • Greenfield projects: Struggles with complex architecture decisions

    Claude Code Weaknesses:

    • Cost barriers: $200/month for heavy usage
    • Static knowledge: No real-time information access
    • Vendor lock-in: Proprietary system with limited extensibility
    • Setup complexity: API key management and billing configuration

    Final Results: Which Tool Should You Choose?

    After extensive testing, the choice depends entirely on your specific situation:

    Choose Gemini CLI if you:

    • Want to experiment without financial commitment
    • Work on smaller projects or individual development
    • Need real-time documentation and community knowledge access
    • Value open source transparency and extensibility
    • Prefer terminal-based workflows

    Choose Claude Code if you:

    Work in enterprise environments with strict security requirements Handle complex, multi-step development projects regularly Need proven reliability for mission-critical applications Can justify the cost through productivity improvements Require advanced reasoning capabilities for architectural decisions

    My Recommendation for Most Developers:

    Start with Gemini CLI for experimentation and smaller projects, then evaluate upgrading to Claude Code if you hit limitations. The free tier eliminates risk, and you can always add paid tools later if your needs evolve.

    For teams, consider a hybrid approach: use Gemini CLI for debugging, documentation, and research tasks, while reserving Claude Code for complex feature development and architectural decisions.

    Conclusion

    Google’s Gemini CLI represents the most significant disruption in AI coding tools since GitHub Copilot’s launch. The combination of free access, open source transparency, and Google Search integration creates compelling value that forces the entire industry to reconsider their pricing and accessibility strategies.

    This isn’t just about one tool versus another – it’s about the democratization of AI-powered development capabilities. Google’s strategy of aggressive free pricing will likely pressure competitors to lower costs and increase accessibility across the board.

    The technology isn’t perfect, and neither tool eliminates the need for fundamental development skills. But for the first time, advanced AI coding assistance is available to every developer regardless of budget constraints.

    My advice: download Gemini CLI today and start experimenting. The worst case is you learn something new about AI-assisted development. The best case is you discover a productivity multiplier that costs nothing and integrates seamlessly into your existing workflow.

    The future of development is collaborative human-AI partnerships, and with barriers to entry this low, there’s no reason not to start exploring that future immediately.