Forem: Andrew Baisden

AI Agents That Actually Work, Building Reliable UI Automation with Amazon Nova Act

Andrew Baisden — Thu, 12 Mar 2026 16:49:25 +0000

AI agents are everywhere these days, but if you’ve tried to get them out of the demo and into production, then you’ve probably hit the same wall, which is production reality. A demo can work once; production has to work all the time, under shifting UIs, flaky network conditions and messy edge cases that are never included in the examples. Nowhere is that gap clearer than in browser and UI automation, where workflows remain painfully manual because traditional approaches are weak, break almost continuously as interfaces evolve, and are expensive to maintain.

Even modern setups usually become fragile Selenium scripts that break when a selector changes, endless maintenance to get tests passing and UI updates turning automation into someone’s full-time job without most people noticing. The real opportunity is not a better demo, it’s something much more practical. Dependable agents that automate repetitive UI work at scale. That’s the gap Amazon is targeting with a product called Amazon Nova Act, which centres around #NormcoreAgents, the mission-critical automation that teams really need in prod.

In this article, we are going to cover:

Why browser agents fail in production
How Nova Act approaches dependable UI automation
A real developer workflow from Playground to IDE and then production
Practical use cases, including QA testing and business automation

This article is sponsored by Amazon.

What Is Amazon Nova Act?

Amazon Nova Act is a service for creating and managing robust AI agents that automate UI workflows over a browser. Think of it as "use the computer", but production-grade.

At a high level, Nova Act is:

A developer-first way to create UI automation agents
Trained and built for actual workflows (QA testing, data entry, extraction, checkout flows)
For success at scale, not small occasional victories
Powered by a custom Amazon Nova 2 Lite model

And the important point is that Nova Act is not just a model. It’s a complete workflow from prototype to build/debug to deploy/operate, centred around the fact that UI automation is hard because reliability is hard.

Why Reliability Is The Hardest Problem In AI Agent Development

If you have ever played around with agentic browser automation, I’m sure that you are familiar with the common failure modes such as flaky behaviour that succeeds once and fails on the next run, workflows that break as soon as a layout or button label changes, awful integration with logging and observability tooling, and the consistent challenge of turning a promising tech demo into something deployable and observable. What appears impressive in isolation is all too often exposed as small under real-world conditions.

At the heart of this matter is a simple problem, which is that intelligence alone doesn’t ship. What actually ships is a system that’s debuggable, observable, repeatable, and safe to run in real workflows. Now, Nova Act’s positioning is something like this, where it can stop stitching random components together and hoping they behave, instead, build UI automation on a foundation designed explicitly for production safeguards.

Developer Workflow: From Playground to Production

Nova Act’s builder experience is meant to feel like the workflow developers actually want:

Prove it quickly
Move into an IDE
Ship when ready

Step 1: Prototype In The Nova Act Playground

The Playground is where you can go from idea to working workflow without bootstrapping a framework.

A typical flow could look like:

Enter the URL you want to automate
Describe the workflow in natural language
Run it in a live browser session
Iterate until you have something reliable enough to refine

Example prompt you might try in the Playground (QA smoke test):

In this upcoming example, we can use the AI agent to browse the Amazon website. A workflow prompt is shown below:

Go to https://www.amazon.com/
Navigate to the Amazon Basics page
Verify that the page loaded and that the "Electronics" button section is visible
Take a screenshot and return a short pass/fail summary

And in the screenshot, we can see what that looks like in Amazon Act Playground right before we initiate the first action.

In this screenshot, we can see how we can use Amazon Act Playground to browse the Amazon e-commerce website.

It's worth noting that the key here isn’t "wow, it clicked buttons." Instead, it’s supposed to be "can I get a workflow that behaves predictably and gives me useful output?" And that's the brilliance of using AI agents: their ability to complete tasks, giving us the ability to offload tasks, freeing up time to work on more pressing matters.

Step 2: Export And Refine In Your IDE

Once your Playground workflow is done, the intended path is:

Export the generated Python script
Create an API key on the Nova Act Dev Tools page
Install the Nova Act IDE extension (VS Code, Cursor, or Kiro)
Import the workflow into Builder Mode
Run step-by-step with a live browser preview and logs

Here you can see what the Download Python script option in Playground looks like:

A Shop_on_Amazon.py file was exported with this code, which is what our agent is using behind the scenes, as it follows our commands:

from nova_act import NovaAct
import os
# Browser args enables browser debugging on port 9222.
os.environ["NOVA_ACT_BROWSER_ARGS"] = "--remote-debugging-port=9222"
# Get your API key from https://nova.amazon.com/act
# Set API Key using Set API Key command (CMD/Ctrl+Shift+P) or pass directly to constructor below.
# Initialize Nova Act with your starting page.
nova = NovaAct(
    starting_page="https://www.amazon.com/",
    headless=True,
    tty=False,
    nova_act_api_key="<your_api_key>"  # Replace with your actual API key
)
# Running nova.start will launch a new browser instance.
# Only one nova.start() call is needed per Nova Act session.
nova.start()
# To learn about the difference between nova.act and nova.act_get visit
# https://github.com/aws/nova-act?tab=readme-ov-file#extracting-information-from-a-web-page
nova.act_get("Navigate to the Amazon Basics page. Verify that the page loaded and that the 'Electronics' button section is visible. Take a screenshot and return a short pass/fail summary. ")
# Leaving nova.stop() commented keeps NovaAct session running.
# To stop a NovaAct instance uncomment nova.stop() - note this also shuts down the browser instantiated by NovaAct so subsequent nova.act() calls will fail.
# nova.stop()

The code is self-explanatory, thanks to the comments and essentially follows the workflow we made.

This is the Amazon Nova Act Dev Tools page, which shows API key creation:

And this is what the Nova Act IDE extension looks like when installing in VS Code/Cursor/Kiro:

Security best practice: don’t leak your API key

Amazon Nova’s docs emphasise a familiar rule, which is to never expose API keys client-side.

Here’s the safe baseline for different OS and environments:

# Mac/Linux
export NOVA_API_KEY="your_key_here"

# Windows PowerShell
$env:NOVA_API_KEY="your_key_here"

And in Python:

import os

api_key = os.getenv("NOVA_API_KEY")
if not api_key:
    raise RuntimeError("Set NOVA_API_KEY in your environment")

Using the Amazon Nova Act VS Code Extension

This is what the VS Code extension looks like once you have installed it. For authentication to work, you must either create an API Key or use IAM authentication; then you will have full access to the Builder Mode.

We can mirror our Playground experience locally in our IDE using Amazon Nova, which is how most developers are likely to use the platform. We will use API Key Authentication to run our shop on Amazon Playground example locally.

Just make sure that you obviously have:

Your development environment set up with an IDE
Python installed on your computer
The Amazon Nova extension is installed in your IDE
An Amazon Nova account and API Key

Then, create a folder for the project on your computer, such as "Amazon Nova Demo". Only two files are needed now, a Shop_on_Amazon.py file and an .env file. The Python file will contain the code to run the build, and the environment file will store your Amazon Nova API key.

See the code below. The files created should be put inside the Amazon Nova Demo folder:

We modified and updated the Shop_on_Amazon.py file from earlier:

import os
from dotenv import load_dotenv
from nova_act import NovaAct

load_dotenv()

api_key = os.getenv("NOVA_ACT_API_KEY")
if not api_key:
    raise ValueError("NOVA_ACT_API_KEY not found")

os.environ["NOVA_ACT_BROWSER_ARGS"] = "--remote-debugging-port=9222"

nova = NovaAct(
    starting_page="https://www.amazon.com/",
    headless=False,   # better for interactive debugging in Builder Mode
    tty=True,
    nova_act_api_key=api_key
)

nova.start()

result = nova.act_get("""
Navigate to the Amazon Basics page.
Verify that the page loaded and that the 'Electronics' button section is visible.
Take a screenshot and return a short pass/fail summary.
""")

print(result)

nova.stop()

This file runs better in build mode and imports our API key.

Our .env file contains only one key: our Amazon Nova API key.

NOVA_ACT_API_KEY="PUT_YOUR_AMAZON_NOVA_API_KEY_HERE"

Now we need to click on the button which lets us open a Python file it looks like an open folder, so select the Shop_on_Amazon.py file and load it, and you should see the file loaded in the Build mode:

Now hit the "Run all cells" button to run the Python script. Running the script gave me a live view of the Amazon website inside of VS Code, and it also opened my Chrome browser at the same time as the agent ran through the process. Of course, this can be configured so you only have the live view or have the agent run in an external browser.

This screenshot shows the build process right at the beginning as the Amazon website is opened:

In this screenshot, we can see the build going through the steps:

The text with the purple background is for the captions, which can be turned on or off.

Example: What the exported script refinement often looks like

Exact Nova Act SDK details vary by environment/version, and the extension can generate its own structure, so think of this snippet as illustrative. The idea is to turn natural language steps into something you can version, test, and maintain:

"""
Example structure for refining an exported Nova Act workflow script.

Goal:
- keep steps explicit
- add checkpoints (assertions)
- capture artifacts (screenshots/logs)
"""

from dataclasses import dataclass

@dataclass
class SmokeTestResult:
    passed: bool
    reason: str

def assert_visible(page, selector: str, label: str):
    # Replace with Nova Act / browser tool assertion helpers from the SDK/extension.
    if not page.is_visible(selector):
        raise AssertionError(f"Expected '{label}' to be visible ({selector})")

def run_smoke_test(agent):
    """
    'agent' represents your Nova Act runtime/driver from the generated script.
    Replace 'agent.page' access patterns with what your generated script provides.
    """
    page = agent.page

    # 1) Navigate
    page.goto("https://example.com")

    # 2) Log in (illustrative)
    page.fill("input[name='email']", agent.secrets["EMAIL"])
    page.fill("input[name='password']", agent.secrets["PASSWORD"])
    page.click("button[type='submit']")

    # 3) Navigate to Pricing
    page.click("a[href='/pricing']")

    # 4) Assertions (critical for QA)
    assert_visible(page, "h1", "Pricing page header")
    assert_visible(page, "button:has-text('Get Started')", "Get Started button")

    # 5) Capture artifact
    page.screenshot(path="artifacts/pricing-page.png")

    return SmokeTestResult(passed=True, reason="Pricing page loaded and key UI elements visible")

This is important because assertions transform "it seemed to work" into "it definitely worked," whereas artifacts (gathering relevant screenshots, logs, etc.) allow failures to be actionable rather than mysterious and explicit checkpoints eliminate flakiness by specifying exactly what success looks like at each step in the workflow.

Step 3: Deploy And Run Agents In Production

Once your workflow is stable locally, Nova Act is able to deploy and operate it using AWS services and tooling. Before you can deploy the agent, you have to make sure that you have these prerequisites:

An Amazon/AWS account
The AWS CLI is installed on your computer
Docker is installed and running

Also, don't forget that Amazon Nova currently only works in the US, so use the AWS CLI to configure your region using this command: aws configure set region us-east-1.

Now, in your IDE, use the Nova Act extension and go to the deploy tab as shown here:

Create an AWS Workflow Definition Name. I used "shop-amazon". You might see a warning in yellow about a workflow not being present. If you click on the button to Convert to Deployment Format it will create a workflow for you.

Alternatively, you can run this command to create a workflow using the CLI:

aws nova-act create-workflow-definition \
  --name shop-amazon \
  --region us-east-1

And then confirm the workflow and region with this command:

aws nova-act list-workflow-definitions --region us-east-1

Before you hit the Deploy Your Workflow button, ensure that Docker is up and running on your computer. Assuming you did everything correctly, you should now be able to deploy your agent as shown here:

Now, when you go to Amazon Nova Act on your AWS account, you should see the workflow you created as I have here:

Real-World Use Cases: What You Can Build With Nova Act

Nova Act is best when the job at hand is repetitive, browser-based, significant enough that automation is warranted, and annoying enough that humans shouldn’t waste their time clicking through it manually.

This scenario is best outlined when seen in a few use cases. Three examples include:

Automated QA testing
Automating repetitive business workflows
Automating developer workflows

Use case 1: Automated QA testing

And this is probably the most immediately practical #NormcoreAgents situation. QA and UI testing are ideal for trusted browser automation because QA often becomes the bottleneck for shipping velocity; UI regressions are painful and often only detected late; more traditional scripts tend to be weak, having high upkeep costs while not detecting issues in production; API tests will fail to catch what real users experience (or don’t) within the interface. Teams need automation that actually represents the full end-to-end journey rather than only backend responses.

Nova Act-style UI testing can fill those gaps with after-deploy automated smoke tests, checkout flow validation, login flow validation, and critical-path regression checks as they traverse environments. Instead of keeping weak selectors alive all over the dozens of scripts, teams can define high-value workflows that run consistently and provide a valuable pass/fail signal before problems reach users.

Here we can see what that looks like in an Audible automated test example:

Example: Audible Smoke test agent spec (human-readable)

Run after each deploy (or nightly):

1) Open https://www.amazon.com/audible
2) Verify the Audible homepage loads:
   - Hero headline is visible ("Love books? You'll Love Audible." OR similar)
   - Primary CTA (e.g., "Explore Membership" or "Start free trial") is visible
3) Navigate to pricing:
   - Click "See all plans & pricing" OR scroll to pricing section
4) Verify pricing cards render:
   - "Standard" plan card exists
   - "Premium Plus" plan card exists
   - Each plan shows a "Try ... Free" CTA button
5) Validate pricing details:
   - Confirm trial text exists (e.g., "30-day trial")
   - Confirm post-trial pricing text exists
6) Test search functionality:
   - Use the top search bar
   - Search for "Harry Potter"
   - Verify search results load
   - Confirm at least one result contains "Harry Potter"
7) Click a result (optional deeper check):
   - Verify book detail page loads
   - Confirm title, author, and trial CTA are visible
8) Capture artifacts:
   - Screenshot: Homepage hero
   - Screenshot: Pricing section
   - Screenshot: Search results page
   - Screenshot: Book detail page
9) Return a structured pass/fail report

It's also worth noting that your agent should not just return "failed", it should return something like this JSON data, which makes it more usable for CI pipelines, Slack alerts, GitHub checks and QA dashboards.

{
  "workflow": "audible-smoke-test",
  "status": "failed",
  "failed_step": "verify_pricing_cards",
  "reason": "Premium Plus card not found",
  "last_url": "https://www.amazon.com/audible",
  "artifacts": {
    "homepage": "artifacts/homepage.png",
    "pricing": "artifacts/pricing.png"
  },
  "timestamp": "2026-03-03T19:05:22Z"
}

Use case 2: Automating repetitive business workflows

Much real work still occurs inside browser tools where automation is clunky: either the system has no API, the API is limited/unreliable, or you’re forced through manual UI steps regardless (uploads, exports, approvals, ugly dashboards). That’s why even deeply technical teams still waste hours each week manually doing simple tasks, not because the tasks are difficult, but because they exist in the UI.

Nova Act shines when the work is UI-centric and otherwise needs a human to click around: updating CRM records, reconciling tickets between systems, copying data from internal dashboards into other systems or pulling reports from third-party portals. Instead of writing one-off weak scripts, you can automate #NormcoreAgents that follow the same workflow every time, store artifacts if something changes between runs and escalate to a human only when it decides real judgement is needed.

Agent workflow: Google Sheets monthly client income tracker (business-focused, human-readable)

This example creates a brand-new spreadsheet and sets up a simple but useful Monthly Client Income Tracker for one month, including basic totals and a clean structure. It uses a Google Sheet.

Run on the 1st of each month (or on-demand):

1) Open https://docs.google.com/spreadsheets/u/0/?pli=1
2) Create a new blank spreadsheet
3) Rename the file:
   "Client Income Tracker — <Month YYYY>" (e.g., "Client Income Tracker — March 2026")

4) Set up the header row in Sheet1 (row 1):
   Date | Client | Project | Description | Invoice # | Status | Currency | Amount | Payment Method | Paid Date | Notes

5) Apply formatting:
   - Freeze row 1
   - Bold header row
   - Turn on filter for header row
   - Set Amount column to currency format
   - Add data validation for Status: Draft, Sent, Paid, Overdue
   - Add data validation for Currency: GBP, USD, EUR

6) Create a second sheet named "Summary"
7) In "Summary", generate monthly rollups:
   - Total Invoiced (sum of Amount where Status is Sent or Paid)
   - Total Paid (sum of Amount where Status is Paid)
   - Outstanding (Total Invoiced - Total Paid)
   - Optional: Total by Client table (pivot-like summary)

8) Capture artifacts:
   - Screenshot: spreadsheet created + file name visible
   - Screenshot: Sheet1 headers + formatting
   - Screenshot: Summary tab with totals visible

9) Return a pass/fail report with:
   - Link to the created spreadsheet (URL)
   - What was created (sheets + columns + validations)
   - Any issues encountered (e.g., permissions, popups)

Use case 3: Automating developer workflows

This is where the developer excitement angle really flies. A robust UI automation agent can automate several routine checks that developers are forced to do day-to-day: post-deploy smoke testing, checking feature flags or settings in admin panels, validating critical pages after a frontend change or performing consistent bug reporting with screenshots and reproducible steps.

Even if you don’t go all the way to automating your entire workflow, having an agent that runs the boring checks automatically is already a massive reduction of manual work. It eliminates the need for developers to manually click through the same pages over and over again, placing that repetitive validation work in the hands of an agent, which can share clear results, saving hours each week while giving engineers more time to build and debug actual features.

Agent workflow: Post-deploy frontend validation

In many teams, developers manually verify a few critical things after every deployment: the homepage loads, key pages render correctly, feature flags are enabled, and nothing obvious is broken. An agent can reliably run those checks and produce a structured report with screenshots, like with this example workflow.

Run after each deployment:

1) Open the production application URL
2) Verify the homepage loads successfully
   - Page title is present
   - Main navigation renders
   - No obvious error messages appear

3) Navigate to key pages
   - /dashboard
   - /settings
   - /pricing

4) Validate page integrity
   - Confirm important UI components render
   - Check that expected headings or CTAs exist
   - Verify navigation links work

5) Check feature flags or admin settings
   - Navigate to the admin/settings panel
   - Confirm the latest feature flag is enabled
   - Verify the new feature toggle appears in the UI

6) Capture artifacts
   - Screenshot: homepage
   - Screenshot: dashboard page
   - Screenshot: feature flag/settings page
   - Screenshot: pricing page

7) Detect errors
   - Look for console error indicators
   - Check for visible error banners or “500” pages

8) Generate a structured report
   - Pass/fail status
   - Failed step (if any)
   - URLs visited
   - Attached screenshots

Human-in-the-loop: keeping humans in control

A reason teams shy away from running UI agents in production is very much to do with the obvious: some decisions should not be automated blindly. And that’s where Human-in-the-Loop (HITL) comes in. Instead of making the agent guess, when it hits something out of the ordinary or sensitive, the workflow can hold and escalate that step to a human who can review and decide how to proceed.

Nova Act’s HITL approach enables agents to keep performing routine automation and offload decision-making moments like authentication flows, CAPTCHA, critical approvals, and sensitive actions such as payments and account modifications. The idea is, as ever, simple: Automation should be confident when it can be confident, and smart enough to ask for help when it can't.

Why Nova Act Fits Modern AI Agent Architectures

Modern agent systems typically implement composed architectures where different parts of the system take care of concrete aspects instead of building everything into a single tool. Nova Act itself provides a high-level model where each Act is an isolated piece of UI automation code that can be reused across different pipelines and needs; it’s a specialised capability (good at being safe) that sits nicely in the developer's experience, from trial to production.

Instead of forcing teams to choose between a quick demo or a fully engineered system, Nova Act aims to provide a path that looks like prototype fast, then engineer properly, then ship.

Some of the main features of this method are:

One component handling orchestration
Purpose-built tools for specialised tasks
Strong observability and debugging capabilities
Patterns for safely executing production workflows
Seamless integration into the developer workflow (Playground to IDE)
Interoperability with other tools (e.g. Python functions, external integration)
A focus on production working, not clever reasoning

Getting Started With Amazon Nova Act

Onboarding is not too difficult when you visit the Amazon Nova Act website. It's fairly straightforward after following the onboarding flow as outlined below:

Visit the Nova Act playground and prototype a workflow in natural language (Agent, Voice Agent, UI Agent)
Export the generated Python script
Create your API key and set it via environment variables
Install the IDE extension (VS Code, Cursor, or Kiro)
Import the script into Builder Mode, run/debug step-by-step
When ready, deploy and run in production

Give Nova Act a try in the playground and share your feedback on social media. You can find more information on the What is Nova Act page on AWS and the Getting started with Nova Act guide.

To learn more, just refer to the Amazon Nova Act Documentation.

Gotchas to know up front:

Nova Act is currently ONLY available in the AWS Region US East (N. Virginia)
You must have a US-based Amazon account to access

The Bigger Picture: From Automation Tools To Autonomous Workflows

We are seeing a renaissance happen across software automation: evolving from weak scripts to intelligent agents, one-off automations to repeatable workflows, and cool demos to workhorse systems, where devs are actually deploying. The real unlock here is being robust; potentially, once agents are working reliably in production, they cease to be a novelty and start to become infrastructure. The sort that quietly saves hundreds of hours for teams while improving product quality. That’s the idea behind #NormcoreAgents: not flashy magic assistants, but solid teammates who take care of the annoying tasks that keep real products functioning.

Conclusion

Amazon Nova Act targets one of the hardest problems in agent tooling today: how to actually build UI automation that holds up in production. The challenge isn’t getting a demo to work; lots of tools can do that. The real value is in supporting the full lifecycle of reliable automation, quickly prototyping an agent in the Playground, iterating on and debugging that workflow from your IDE, deploying and operating those workflows until they’re ready for production use.

The use cases are right this second useful: automated QA testing; repetitive business workflows, developer productivity automations that contract out hours of guide work each week. If you're adventurous, play with Nova Act in Playground and create a simple #NormcoreAgent that does something you already do manually but saves your time.

A big thank you to Amazon for sponsoring this article and making it possible to benefit the developer community.

Stay up to date with AI, tech, productivity, and personal growth

If you enjoyed these articles, connect and follow me across social media, where I share content related to all of these topics 🔥

I also have a newsletter where I share my thoughts and knowledge on AI, tech, productivity, and personal growth.

I Evaluated Enterprise Auth for a SaaS App and Here’s My Honest Take on WorkOS AuthKit + Radar

Andrew Baisden — Thu, 15 Jan 2026 17:02:24 +0000

Every SaaS product eventually encounters the same problems.

Early on, authentication is a checkbox:

"Users can sign in"
"Teams can invite people"
"Admins can reset passwords"

Then enterprise leads show up. Next thing you know, you’re dealing with questions about SAML, SCIM, just-in-time provisioning, role-based access and security, all of which you would rather not turn into roadblocks for product development. This is the point at which most teams realise that the "good enough" auth stack they put together is now a burden.

I tried WorkOS AuthKit and Radar, looking through that lens:

Not "Can I ship login fast?” but “Can this get me from Series A to real enterprise contracts without rewrites?”

In this post, I explain my thoughts and why, as I find out just how powerful WorkOS is for implementing modern enterprise auth in applications.

This article is sponsored by WorkOS. All opinions are my own, based on hands-on evaluation and real-world SaaS decision-making.

The real problem WorkOS is solving (and it’s not login UI)

Most modern auth tools are optimised for developer satisfaction at day zero. WorkOS is optimised for company survival on day 900.

The core idea is simple:

Keep enterprise identity complexity behind a clean API, so it doesn’t leak into or complicate the rest of your product code.

Let's break this down to see what that looks like:

AuthKit handles how users authenticate
Radar handles who should be blocked before they become a problem
Admin Portal handles who your support team doesn’t want to talk to at 2 am

Individually, these exist elsewhere and together, they form something closer to an enterprise onboarding system, not just auth.

AuthKit is opinionated where it matters, and flexible where it counts

AuthKit is essentially a pre-built, customisable authentication experience which has been created around WorkOS primitives and powered by Radix UI. In my testing, what stood out to me was the fact that:

You are not trapped in the "startup aesthetic": It is possible to use a different theme and customise without fighting default settings
It is agnostic: You can deploy everywhere, with server-rendered apps, Modern SPAs or Hybrid Stacks
You can design for identity features that you don’t want to reimplement: MFA, magic links, RBAC, passwordless, JIT provisioning; it’s already a baked-in part of the model.

It's not competing to win a prize on originality; it’s trying to prevent future refactors, and yes, NextJS integration is excellent.

Radar is security that doesn’t wait for abuse to happen

Many teams see fraud and bot protection as a generic add-on, but Radar turns them on their heads. Unlike bolted-on reCAPTCHA or retrofitted rate limits, Radar integrates into the authentication layer to:

Detect automated abuse
Block credential stuffing
Reduce fake account creation
Defend enterprise login flows before they can be exploited

What I liked here is the placement. Radar doesn’t live in "security tooling land." It lives where identity decisions already happen. And in my opinion, that’s the right architectural choice.

The Admin Portal quietly does the most valuable work

This is the part that most devs don’t take into account, until they’ve been burned. The Admin Portal provides customer IT teams with the ability to:

Configure SSO
Manage directory connections
Onboard customer without engineering assistance

This directly reduces:

Support tickets
Custom onboarding calls
"Can you hop on Zoom with our IT team?" requests

If you’ve ever been the engineer brought into enterprise onboarding calls, you instantly get the value here.

Where WorkOS fits, and where it doesn’t?

This is the most important section, because it gives us a grasp on how well WorkOS can be integrated into your own workflow.

WorkOS works well if:

You are building a B2B SaaS with enterprise goals
SSO, SCIM, and compliance are already being asked on sales calls
You want identity to be infrastructure, not a product-surface
You are thinking in terms of long-term stability and not short-term convenience

WorkOS is less suitable if:

You’re working on a consumer app or side project
You desperately need deep auth customisation for UX tweaking
You don’t want to pay for enterprise-grade features in the future
You depend heavily on a non-NextJS stack today (support is getting better, but you get the idea)

It is not a one-size-fits-all tool, and that’s perfectly fine.

How does WorkOS compare to other competitors?

This isn’t a feature-by-feature breakdown. It is what those tools feel like when you move beyond Minimum Viable Product (MVP) and start interacting with real customers, real security concerns, and actually scaling.

Auth0: Battle-tested and powerful, with solid enterprise features; however, also more heavyweight, complex and expensive as you grow. You’re paying for flexibility, whether you want it or not.

Clerk: Fantastic developer experience and lightning fast to ship early. Good choice for startups, not a priority for enterprise onboarding (SSO/SCIM/IT-led setup).

Kinde: Clerk in spirit, clean DX, quick wins, good defaults. The perfect fit when speed is better than long-term enterprise solutions.

Stytch: Pretty powerful and modular, with nice APIs. It can be like Lego blocks, where you assemble it yourself, as opposed to a more thorough enterprise onboarding system.

Descope: Robust no-code / low-code auth workflows and flexibility. It is powerful, but also opinionated, in a way that might not be great for teams who prefer Auth to stay out of the way.

Ory: Open-source, and a platform worth checking out, as it is very flexible. Great, if you actually want full control and aren’t afraid of having to maintain complexity in infrastructure and long-term support.

Amazon Cognito: Plenty of scalability and built into AWS. Very developer-oriented with lots of complex configurations and setups.

Firebase: Good for shipping a product quickly. Enterprise identity (SSO, directories, IT-managed onboarding) can be tricky, though.

Supabase Auth: Amazing DX, and it has an open-source feel to it. Similar to Firebase, awesome at the startup level, but enterprise requirements would drive you to a custom solution.

Frontegg: A decent amount of enterprise focus, many things are already built in. Might be heavy and product-defining (not infrastructure you quietly rely on).

Better Auth: More approachable and developer-centric. Perfect for people who want to have a framework-agnostic solution and don’t yet need enterprise-grade identity workflows.

Where WorkOS comes in

It might not be the absolute quickest way to have a demo login, but it’s one of the cleanest paths from "startup auth" to enterprise-ready identity without rewriting half your stack down the road.

WorkOS covers a lot of bases and does it very well, which makes it a good all-around provider.

The trade-offs you should actually think about

No tool is free of compromise.

What really surprised (me in a good way) is how well AuthKit and Radar seem to work together. They don’t appear like a set of loosely linked features, but more like parts of one system, engineered to address real enterprise identity issues. Much of the detailed control you would normally have to deal with around SSO, provisioning, and abuse protection is still there, but it’s purposefully buried behind default settings and a clean UI that never makes you feel like you’re staring into a black box.

What didn’t work quite as well is largely a matter of scope and timing. Stack support beyond NextJS is still a little bit constrained, something that will be important to teams running less popular configurations. The free tier is great for exploration, but doesn’t really show off what WorkOS can do; most of the value only becomes clear when you’re really trying to think through enterprise use cases.

Finally, integrating with WorkOS is as much a mental shift as a technical one: you're basically choosing to continuously look at your product's future from an enterprise ready lens. If you’re one of those hoping to stay small forever, then this will likely all seem like overkill. For people who do hope to grow, it is much more like insurance.

Conclusion

WorkOS AuthKit and Radar will not instantly make your product feel magical. They will make your sales pipeline less fragile, your security stronger, and your engineering roadmap quieter.

If you already have enterprise goals, even if they’re barely there, it’s worth assessing now instead of putting them off and giving WorkOS a try.

Explore AuthKit
Explore Radar

Stay up to date with AI, tech, productivity, and personal growth

If you enjoyed these articles, connect and follow me across social media, where I share content related to all of these topics 🔥

I also have a newsletter where I share my thoughts and knowledge on AI, tech, productivity, and personal growth.

How I Automated My Workflow Using Zapier and Why You Should Too

Andrew Baisden — Thu, 11 Dec 2025 15:17:43 +0000

The beauty of automation isn’t just in the time-saving; however, it’s about creating systems that work efficiently behind the scenes to support your work that you can constantly push forward in building your actual projects. And here in this article, I’m going to share a real Zapier workflow that I built for something I wanted to automate, tracking content across Google Sheets and Notion.

You will even understand how it all works: why decisions matter, what you can learn from the behaviour of Zapier triggers and polling, or row detection. If you are interested in automation or productivity, or if you are just trying to create a smarter workflow for yourself, I thought this breakdown might give you some more cool evidence of what's happening behind the scenes.

Prerequisites

We need to set up a few accounts before we can start. Most people already have a Google account and ChatGPT. So all that's left is creating an account for Notion if you don't have one already.

A Google account
A Notion account
A ChatGPT account
An OpenAI API key

Many tutorials show you how to create an OpenAI API Key; just be aware that billing is required to use the API Key with any app you build. Fortunately, it's not that expensive, and you only need to top up something like £10/$10 to get started, and for our usage, that's more than enough.

What We Will Build

We are going to build an automation content pipeline for generating content ideas.

Our Zapier Zap will automate our content pipeline by taking new ideas from one of our Google spreadsheets, followed by turning them into posts inside our Notion database, so we don't need to do any manual copying.

This is what our final Zap workflow will look like once it has been completed:

Our automation handles 3 major tasks as outlined below:

1. Detects new ideas we add to our Google Sheet

Whenever we add a new row (a new content idea), Zapier sees it instantly.

2. Send that new idea to our Notion database

It creates a brand-new Notion entry with our fields:

Name
Tags
Outline
Raw Idea
Created From

3. Updates the status in your spreadsheet

After the idea is successfully added to Notion, Zapier marks the row (“Processed”) so we know:

Which ideas have synced
Which ones still need action
What’s safe to edit or publish next

This prevents duplicates and keeps both systems in sync.

Setting Up a Zapier Account

The first step is to visit the Zapier website and create a free account by clicking on the sign-up button.

You can either sign up with an email of your choice or use your Google account to sign up.

You should now see the Zapier dashboard screen as shown here:

There are many ways to build an automation on Zapier. In this tutorial, we will start from scratch and create a Zap. So click on the Zap (automated workflows) button to begin.

The create Zap workflow automation screen should now be visible:

In the next section, we shall go through a build setup for our content pipeline.

Building Our Content Automation Pipeline

We can create our Zap in 4 steps! Let's get started with step 1 and go through them all.

Step 1. Trigger - New Spreadsheet Row

Google Sheets is going to be our event trigger. Anytime a new row is added to our Google Sheet, the workflow will update with the new data. So firstly, create a Google Sheet called "Idea Inbox" and then give it these column headings:

A: idea
B: status
C: notion_url

Now, inside Zapier, click on the Trigger button, and you should see a pop-up menu with extensions:

Select Google Sheets and on the Setup screen, add this event:

Trigger event: New Spreadsheet Row

Make sure that your Google Account is connected if it's not already.

On the Configure screen, add these values:

Spreadsheet: Idea Inbox
Worksheet: Sheet1

If you changed the names, then update accordingly.

On the test screen, test the trigger to make sure that it works. You need to create a row with some data in your spreadsheet first; otherwise, the test will fail. You can use this test data or create your own:

idea: Build a to-do app
status: pending

You don't have to put anything in the notion_url cell, as our Zap is not connected to Notion yet.

Congratulations, that's step 1 completed, now onto step 2.

Step 2. Action - Conversation

In this step, we now need to connect to ChatGPT so that we can use the API and LLM for our conversations.

Like before, click on the action button, but this time find ChatGPT. Add this action event on the setup screen, and of course, make sure that your ChatGPT account is connected:

Action event: Conversation

Now use this configuration here for our Conversation on the Configure screen. I'm using the current latest model; it could have changed depending on when you read this, so select whatever model you want.

Here's the User Message:

Turn the following raw idea into a clear, structured Notion page outline. Include:

Title
Description
Problem it solves
Proposed features or sections
Potential use cases
A short action plan for building or writing it

Raw idea:

Now, for the Raw idea, we have to connect our Google Sheet, and to do that, we must use a forward slash like this "/", which will open a context menu as seen here. Then you can select the idea column:

All the other values can remain as default. On the Test screen, go ahead and test the Action. If you see output data, then it worked!

Ok, don't publish yet, we have to do step 3 next, which is connecting to Notion.

Step 3. Action - Create Data Source Item

Notion database setup

Before we start, let's quickly create a database in Notion and also connect our Notion account to Zapier if it has not been done already. Create a Notion page like this one:

Name: Leave as default
Tags: Multi-select
Outline: Text
Raw Idea: Text
Created From: Text

You might also need the Notion Database ID for Zapier, alongside the Zapier Notion extension, which is definitely needed for the database page:

When you connect Notion to Zapier, ensure that you connect to the page you created.

There is a chance that you might encounter a scenario where Zapier can connect to your Notion account, but Notion is not permitting Zapier to access your database/page. In this type of situation, you have to check the sharing permissions for your Notion account and the page.

Zapier workflow setup

Click on the cross in the workflow to add another event, and this time find Notion. On the Setup screen, add Create Data Source Item as the Action event.

Now go to the Configure screen and add this information:

Data Source: Idea Vault
Template Mode: No template
Name: Use "/" to bring up the context menu and find the "idea" column for the Google Sheets extension
Outline: Use "/" to bring up the context menu and find "Output Text" for the ChatGPT extension
Created From: Automated Idea Generator
Raw Idea: Use "/" to bring up the context menu and find the "idea" column for the Google Sheets extension
Tags: You can leave it empty
Content: You can leave it empty
Content Format: Plain Text

Run a Test like usual, and this time you should see the data in our Notion database:

We are almost done; only one step remains.

Step 4. Trigger - Update Spreadsheet Row

To complete our Zap, we just have one last thing to do. Our spreadsheet needs to be updated every time we make changes, and the status has to change to "Processed". The notion_url for our idea in the database should be added to the spreadsheet automatically.

Start by creating another trigger in the workflow and add Google Sheets again. This time in the Setup, make the Action event Update Spreadsheet Row.

On the configure screen, if you see a "Possible Zap loop detected" warning, you can ignore it. It's just a warning, and our workflow trigger will be different this time, so it's fine.

Now add these values to the form on Configure:

Drive: Leave empty
Spreadsheet: Idea Inbox
Worksheet: Sheet1
Row: Click on the 3-dot menu on the right and select Custom. Use "/" to bring up the context menu and find the "Row ID" column for the Google Sheets extension
idea: Use "/" to bring up the context menu and find the "idea" column for the Google Sheets extension
Status: processed
notion_url: Use "/" to bring up the context menu and find the "URL" column for the Notion extension

That's it, the Zap should be ready to publish by clicking the publish button! You can go ahead and give your Zap a name so it's not untitled anymore. On the main dashboard for your Zaps, you can see their Status and choose to toggle them on and off.

Test your automated workflow by creating an idea in your Google Sheet. Zapier will run through the workflow and then put the data inside your Notion database!

Zapier Behind the Scenes: Triggers, Polling, and Row Detection

Once you get going automating workflows with Zapier, it’s good to know what’s happening behind the scenes. Your Zap is good, and your tests appear to work fine, but there are a couple of things going on behind the scenes that explain why deleted rows don’t re-fire, why it matters how quickly we poll, and why the tests took such unequal amounts of time.

Why do deleted rows not re-trigger the Zap

Zapier watches for new rows being added to your spreadsheet, not rows being changed, removed, or overwritten. After some time, Zapier finds a certain ID, which is in memory; it will never treat it as "new" regardless of deleting it from the list. It’s more to stop loops and triggers from being triggered multiple times, but it also means that if you delete the row, then those won’t come back into your automation.

How polling frequency affects workflow speed

Zapier is not actively watching your data in real time. It polls on a schedule, which means it checks in. Free and lower-tier plans take much longer; higher plans are checked more frequently. Quicker polling will result in your workflow being more reactive as opposed to having slower polling, which may lead to longer delays between triggers.

And this is why it can take a while for data to show up in Notion after we add it to the Google Sheet. For a production-level experience, a paid plan would offer a far better experience. For our simple testing, though, it's ok.

How Zapier detects new rows

Zapier doesn’t scan the entire spreadsheet every time. It simply looks for rows with IDs it hasn’t seen before.

When it finds one:

It captures the row data
Passes it to the next step
Stores that row ID so it won’t trigger again

This makes Zaps lightweight and efficient, but also means your workflow relies on predictable row creation, not editing or reordering existing ones.

Conclusion

The power of automation is gained when you know not just what works, but why it works the way it does. Polling frequency, triggers, and detection rules in Zapier might be invisible, but they impact everything from the speed of your workflows to which rows are skipped or ignored.

Once you get how the stuff works, you can create automations that are consistent, predictable and go along with what you are trying to achieve. Whether you are creating a content funnel, workflow productivity system or your first automated workflow process, the strategies I covered here will improve your thinking about the tooling you use and how those tools can work for you instead of the other way around.

Stay up to date with AI, tech, productivity, and personal growth

If you enjoyed these articles, connect and follow me across social media, where I share content related to all of these topics 🔥

I also have a newsletter where I share my thoughts and knowledge on AI, tech, productivity, and personal growth.

Choosing the Right Debugging and Session Replay Tool - Multiplayer vs LogRocket, Sentry, Datadog, and FullStory

Andrew Baisden — Tue, 25 Nov 2025 13:22:41 +0000

When people report bugs or performance problems, developers need more than logs and metrics; they need context. That’s where debugging and session replay tools enter the picture. These platforms log users' interactions, console logs and network activity, giving teams a window into what really happened before the error occurred.

Some popular tools like LogRocket, Sentry, Datadog and FullStory have already established themselves as essential in modern product teams. They give companies the ability to issue track, and this results in better user experiences and the alignment of engineering with design.

But a new player in the space, Multiplayer, is betting on developer-first debugging and visibility, which is based around live collaboration, rich context and without any vendor lock-in.

This article will compare Multiplayer to LogRocket, Sentry, Datadog, and FullStory, breaking down their main features into an easy-to-digest pros and cons read through in order for you to choose the right one for your team.

What is Multiplayer?

Multiplayer is an all-in-one debugging and session replay platform for developers. It brings together full stack session replays, and collaborative tools in a single place, offering a seamless integration within your current workflow. Multiplayer was founded by Steph and Thomas Johnson in 2023, and its product was in beta back in February 2024. They finally opened their platform to the public in the same year and have been enjoying growth ever since.

Unlike traditional monitoring tools, Multiplayer doesn’t just tell you what went wrong; it helps teams reproduce, discuss and fix issues faster. Also you don’t need to worry about any vendor lock-in; and it is possible to export your data and have it sent to you if you ask the Multiplayer team.

It's worth mentioning that with other session replay tools you need to rely on their backend instrumentation to add traces, logs, etc. to your session replays (if they even, support that!). Like for example if you're using Sentry, you also need to instrument Sentry in your backend.

Multiplayer is built on OpenTelemetry (OTel) which is an open source observability framework for providing IT teams with standardized protocols and tools which can collect and route telemetry data. This basically means that you can use any of your existing observability tools, with no need to switch (or, you can switch, whenever you want, to whatever observability stack you want).

Some of the standout features include:

Live cross-team collaboration: Share debug sessions with teammates in real-time, like Google Docs for debugging. It's not just shared visibility, but also the ability to annotate recordings, so engineers, designers and PMs can look at the same replay data without losing any context
Full-stack data capturing: Collect full-stack data from UX and console errors, to backend traces, logs and request/response errors
Multiple recording modes: Multiplayer offers 3 recording modes, while other tools have one or two at most. On-demand mode allows you to manually start and stop recordings, while Continuous mode lets you record in the background while you work (both available via browser extension, in-app widget, or SDK). Conditional recording allows you to silently collect session replays of users visiting your app, based on customizable parameters you set in the UI or through the SDK.

AI-ready Session Replays

Another feature worth mentioning is AI-ready session replays. Modern debugging is not just about what happened; it’s about making that context directly available where you are working. Multiplayer's AI-ready session replay feature does exactly that. It features native support for the VS Code Extension and the MCP server, so Multiplayer can bring full-stack session recordings directly to your IDE and AI assistants. This means that they can be armed with complete context to reason, suggest fixes, or automate away repetitive tasks in an entirely new league of features.

From inside VS Code, you can browse through user sessions, review traces and actions as well as network data, and instantly navigate to relevant code paths, all without ever leaving the editor. The AI copilots can have the same access to these recordings and can immediately know what caused a bug, how the system behaved, and what potential changes are necessary to fix it without having to switch tabs or do guessing.

Multiplayer even extends it with the MCP server, as every session is designed for machine learning, user action, log and trace, request and response headers, and annotations are available for your AI IDE or assistant. Things such as cursor position, Claude Code’s commands for classes and methods completion, Copilot’s suggestions, Windsurf files, among other things. That means your AI tools can serve up precise debugging plans, code fixes, and feature dev proposals all from your live Session Context.

In essence, Multiplayer is intelligent asset creation from your replays, each session able to tutor, explain, or contribute something new. By connecting human context with AI reasoning, it turns debugging from an individual manual task into a collaborative, context-aware process that improves over time.

In other words, Multiplayer takes debugging from something you do alone into a social, high-visibility event.

Multiplayer vs LogRocket

What LogRocket Does Well

LogRocket is among the most popular session replay tools. It captures DOM mutations, network requests, and console logs, providing visibility into what exactly the user is interacting with. It is generally used for frontend issue tracking, UI analysis, and product analytics.

Where Multiplayer Stands Out

LogRocket is incredible for visual replays, but Multiplayer is purpose-built for debugging complex technical issues and cross-team collaboration. It’s designed for full-stack visibility so you can easily jump directly from a replay to your stack trace, all in a single interface.

Whereas LogRocket is built on top of third-party integrations like Sentry for logs and traces, which only show you sampled data to begin with, not endpoints or payloads. Multiplayer is full-stack out of the box, including in each session logs, traces, and headers by default.

LogRocket has a rich library of integrations indeed because it doesn't natively support many features or data points. For example, while Multiplayer includes user feedback in session replays by default, with LogRocket, you’d only be able to view this information by adding the replay links in a third-party customer support tool.

In conclusion, Multiplayer eliminates the legacy data lock-in and fragmentation of outdated platforms and provides teams with a fully integrated, developer-first debugging experience.

Ideal Use Case

LogRocket: UX teams and PMs who want to study user behaviour and performance metrics
Multiplayer: Support and Engineering teams who need fast, actionable debugging context and real-time collaboration

Summary Table

Taking a look at the summary table, we can see how both of them compare across some feature sets.

Feature	LogRocket	Multiplayer
Session Replays	Yes	Yes
Collaboration	Limited	Advanced
Full-stack Data	No	Yes
Vendor Lock-in	Yes	No
Developer Focus	Limited	Yes

Multiplayer vs Sentry

What Sentry Does Well

Sentry is an error and performance monitoring tool. It does a great job in getting exceptions, traces and stack from backend and frontend applications. It’s most powerful for alerting, crash tracking and performance analytics.

Where Multiplayer Stands Out

Sentry is great at telling you when something is broken. Multiplayer however, shows you how it broke. With full stack replays and collaborative debugging tools, Multiplayer fills in the gap of visibility that fits in between what Sentry reports and what developers need to actually reproduce and resolve issues more quickly.

Unlike Sentry, which is primarily an error-monitoring tool that has since added session replays as a feature, Multiplayer was built from the beginning to cater for support workflows and cross-team collaboration. Multiple recording modes and versatile install options allow you to have more freedom in both what and how you record.

Multiplayer also records all the things in a session, not just errors and stack traces, but also user feedback, (un-sampled) traces, as well as request and response content, including full headers.

And beyond visibility, Multiplayer makes debugging a shared activity. Teams can annotate replays, share notes and collaborate in real-time with the injection of built-in notebooks and comments, which Sentry just does not offer.

In other words, Sentry tells you what went wrong, whereas Multiplayer helps you understand why and how to fix it, with your team.

Ideal Use Case

Sentry: Teams who want robust error tracking and alerts across backend and frontend
Multiplayer: Teams who want session replays, and context-aware collaboration and editing tools

Summary Table

Again the summary table illustrates how they compare feature by feature.

Feature	Sentry	Multiplayer
Error Monitoring	Yes	Yes
Session Replays	Basic	Advanced
Collaboration	Minimal	Advanced
Backend Tracing	Yes	Per session, un-sampled
Frontend Debugging	Partial	Yes

Multiplayer vs Datadog

What Datadog Does Well

Datadog is a giant in observability as well as infrastructure monitoring, APM, logs, traces and more. It’s great for large scale production systems which require the visibility to access distributed environments.

Where Multiplayer Stands Out

Datadog is made for tracking systems, stats and infra monitoring. Multiplayer instead is focused on full-stack sessions and the human side behind troubleshooting technical support issues. It allows engineers to understand exactly what happened for each user bug (from the user actions to the correlated traces and logs), without spending hours searching for this specific information among dashboards and logs.

In reality, Multiplayer isn’t a replacement but a complement to Datadog: the latter is still great for high-level observability; however, Multiplayer significantly increases efficiency in certain workflows such as debugging and repro-ing issues, and collaborating on support across teams. It integrates smoothly with your stack so you can have end-to-end visibility without having to manually capture context for each issue.

Although Datadog RUM provides frontend monitoring, building holistic observability would require you to embrace the whole of their ecosystem, APM, logs and infrastructure modules, with potential vendor lock-in. And even then, these replays are typically incomplete: they lack user feedback, request and response content and headers, etc. creating the need to chain multiple tools together. Datadog is also SaaS-only, excluding teams that require data to be self-hosted due to privacy laws, residency or complex regulatory requirements.

Multiplayer, on the other hand, gives you full backend-agnostic visibility right from the start. It retains everything in a session, like user feedback, un-sampled traces, full request and response data, headers, all of it nicely organised for machine learning consumption. As it's powered by OpenTelemetry, it plugs into whatever observability platform you already have and shares full session context directly with your IDE or AI assistant for quicker, more accurate fixes. It runs in any environment, be that production, staging or development and from cloud to on-premises, from serverless to hybrid, with the option for SaaS or self-host.

In other words, Datadog is for system health, and Multiplayer is for session clarity, with the whole narrative from crash to resolution.

Ideal Use Case

Datadog: Ops and DevOps teams monitoring cloud infrastructure and application performance
Multiplayer: Support and Engineering teams diagnosing browser-specific issues and UX user behaviours

Summary Table

Looking through the feature summary table we can see the difference between them and how they compare.

Feature	Datadog	Multiplayer
Infrastructure Monitoring	Yes	No
Backend Tracing	Yes	Per session, un-sampled
Session Replay	Basic (add-on pricing)	Yes
Collaboration	Basic	Advanced
Frontend Debugging	Basic	Yes

Multiplayer vs FullStory

What FullStory Does Well

FullStory is well known for its high fidelity session replays and product analytics. It’s great for reading user journeys, where friction occurs and conversion funnels. It is popular among marketing and UX teams who want data-based insights.

Where Multiplayer Stands Out

Multiplayer isn’t focused on marketing metrics or analysis of user behaviour (i.e. engagement graphs or heat maps); it was designed to solve real-tech problems. It cares about the things that developers need: console logs, call stacks, backend logs, requests/response content and headers, collaborative annotations.

While FullStory seems to have a lot of detailed user analytics, it doesn’t provide meaningful backend correlation like for example, you can’t tie the session to real logs, traces or request/response content. Even LogRocket offers richer technical visibility with third-party integrations. Multiplayer brings your frontend and backend data together natively.

Ideal Use Case

FullStory: Product and UX teams optimising user flows and engagement
Multiplayer: Support and Engineering teams solving bugs and user issues collaboratively

Summary Table

Comparing the two helps us understand where each of them excel.

Feature	FullStory	Multiplayer
Product Analytics	Yes	Minimal
Session Replay	Yes	Yes
Full-stack Data	No	Yes
Collaboration	Limited	Advanced
Developer Focus	Limited	Yes

Feature Comparison Snapshot

Taking everything we have learned into account its now more obvious to see where each tool stands and in what areas they are most relevant in as you can see here in our final feature comparison snapshot table.

Feature	Multiplayer	LogRocket	Sentry	Datadog	FullStory
Session replay	Yes	Yes	Basic	Add on	Yes
Full Stack Data	Yes	Partial	Partial	Partial	No
Error Monitoring	Minimal	Yes	Yes	Yes	Basic
Collaboration Tools	Advanced	Basic	Basic	Basic	Basic
Developer-first Design	Yes	Basic	Yes	Basic	No
Product Analytics	Basic	Yes	Basic	Yes	Yes
Vendor Lock-in	No	Yes	Yes	Yes	Yes
Multiple recording models	Yes	No	No	No	No

Which Tool Should You Choose?

Each tool has its own advantages and disadvantages and choosing one for your application ultimately comes down to preference.

When making a decision we have learned that:

Multiplayer: Excellent for engineering and support teams who wish to conduct rapid, collaborative debugging with full visibility and no data lock-in
LogRocket: Great for frontend UX teams who require detailed replays and product performance metrics
Sentry: Good at error tracking and alerts for your applications on the backend, mobile, game consoles and frontend
Datadog: Fantastic for infrastructure and operations teams that manage very large, high-scale systems
FullStory: Ideal for product and marketing teams who need to dive deep on user behaviour & engagement

It's worth noting that every platform mention with the exception of FullStory offers a free plan including a trial period. Prices vary but there is the option to choose between monthly and annual billing. They also offer various packages all with different features as you would expect such as free, pro, teams, enterprise etc... Costs change all the time so please go to the individual websites to see the latest prices for each subscription.

Conclusion

Debugging and visibility tools are critical to keeping the things we build running smoothly, and as we all know easier to use products are good for everyone. However not all of them serve the same purpose.

If your team is looking for a modern, developer-centric approach that combines replays, debugging context, and real-time collaboration then Multiplayer is a very strong contender. It closes the gap between classic monitoring and getting your hands dirty with debugging, enabling teams to visualise, understand, and get around issues more quickly than ever before.

Take a look at Multiplayer which is an excellent modern alternative for debugging and session replays.

My AI Agent Team - 7 AI Tools For Getting Things Done

Andrew Baisden — Thu, 06 Nov 2025 17:43:54 +0000

At this point, everybody has one favourite AI app they use for work.

I have taken it a bit further. This year, I assembled (no pun intended) my own AI agent dream team, a group featuring seven of the best AI models around. Each has its own special characteristic, personality and speciality.

A lot of the time, I even use the same prompt in all of them just to see what different answers they show me. It’s like a group of experts debating ideas, in real-time, everyone with an opinion and a style.

And because all of these models are at or near the top in LLM leaderboards, I know that it’s giving me some of the best reasoning, knowledge and insight out there at the moment. Below is the full lineup of my team of AI agents, how I utilise them, what they excel at and why you might want to build some yourself.

1. ChatGPT The All-Around Powerhouse

ChatGPT is my all-purpose assistant. It’s excellent for the coders, thinkers and content writers, planning daily activities or creating images. Whether I’m writing code or brainstorming ideas, ChatGPT gets the job done.

The recent models also have more of a talkative personality, reason better and can handle longer contexts. I use it as my daily driver for most tasks like productivity, general tasks and coding. On mobile, it’s my favourite for fast research and idea dumps when I’m on the go. It’s the way your reliable co-worker always comes through because it's fast, smart and well thought out. It's also very good at generating images.

2. Claude The Calm Strategist

Claude can act as a second brain. It’s great for structured reasoning, long-form writing and big-picture thinking. Even though ChatGPT is great for problem-solving and quick tasks, Claude sometimes shines when I need to take a step back and dig deeper, like when analysing docs, decoding complex concepts or brainstorming projects.

It’s also still one of the best coding LLMs out right now, especially when it comes to producing clean and readable code. If I’m focusing on an article, a tech review or a deep work session, Claude is a good choice.

3. Qwen The Researcher

Qwen is one of the up-and-coming stars in my AI rotation. It's a great tool for data collection, analysis and research. It can hunt down citations, detail studies and sort through niche technical topics pretty well.

It’s also good at coding, maybe not as slick as ChatGPT or Claude, but fast and flexible. I use Qwen when I want an alternative or want to see a different perspective on something.

ChatGPT and Claude often take the lead; Qwen is a great alternative for some tasks or when the others are busy.

4. Grok The Real-Time News Expert

Grok, developed by xAI, reads directly from Twitter/X. Basically, for me, it’s the AI news engine that helps keep me up to date on tech, AI and world events, all in real time.

I use it to:

Track trending topics
Receive instant inspiration while browsing
Summarise what’s happening in tech, news, and everything else

It’s also great for live research and discovery because it is plugged into the conversations going on online. If I want to know what’s hot or what the devs are talking about today, Grok is the one.

5. Gemini The Polished Problem-Solver

Gemini seems like a natural multitasker. I find that it is a great tool for structured problem-solving, summarisation and quick fact questions.

It’s not always as wild and inventive as ChatGPT or Claude, but it’s solidly reliable, and of course, so deep in Google’s ecosystem, which makes it ideal for when I’m researching notes in Google Docs or Drive, or even browsing YouTube videos.

I use Gemini all the time when I’m looking for a second opinion on something technical or factual. I guess you could say it's my "grounded" agent, which is less opinionated and more balanced. Image creation is right up there with the best platforms, too.

6. DeepSeek The Document Analyst

DeepSeek is one of my favourite tools for when you need something more like an ask-heavy research task. It's pretty impressive because you can upload and then analyse large numbers of files.

I use it when I’m doing document insight studies or comparing any large reports or technical papers. When I need to sort through a complicated dataset or a research paper, DeepSeek is my data scientist because it can handle multiple attachments more so than other LLMs and all for free.

7. Perplexity The AI Search Engine

I turn to the A.I., based search engine Perplexity for web searches all the time these days. It’s like Google on steroids because it goes deeper, is sourced, and explains things well.

I use it when I need to look something up quickly or verify facts. It’s great for brainstorming too, as I can search for something like "best JavaScript frameworks", and it will condense everything and even create a summary in a table.

It’s less like talking to a chatbot and more like talking to a research assistant who can think critically. Perplexity is also baked into the Comet Browser, so I can use it natively in my primary browser all the time.

How I Use Them Together

Here’s the fun part: I don’t use these tools separately; I treat them like an AI team.

When I’m exploring a topic, I will most times use the same prompt in multiple model tools like for example, asking all of them:

"What are the key trends shaping AI development in 2025?"

Each one responds differently, like they are individuals in a team:

ChatGPT might give a broad, structured overview
Claude offers a calm, reasoned breakdown
Qwen pulls in research-heavy details
Grok gives me the latest trending context
Gemini adds factual precision
DeepSeek analyses data sources
Perplexity wraps it all up with verified references

It’s like having a debate between world-class experts, and I get to listen to all sides before forming my own conclusion. I even have the same setup on my phone because I have the mobile apps for all of them, so I can repeat the same process on the go. It truly feels like having a team of AI agents or team members everywhere you go.

Conclusion

This year, a single AI model is no longer enough. We have a huge choice of LLMs and each has its own strengths, personality and bias, and that’s why I use many of them together. Viewing them as a panel of experts makes for fast, easy and deep learning and information gathering.

And because all of these models are trying to be at the top of the global LLM leaderboards, I know I’m getting best-in-class reasoning and the most up-to-date insights.

AI isn’t changing the way we work; it’s improving the way we think. And you know what that really and truly is, a lot of people's most productive upgrade in many years.

How AI Browsers Are the New Hotness and What This Means for Us

Andrew Baisden — Wed, 05 Nov 2025 16:56:09 +0000

AI is everywhere these days, and it looks like our web browsers will be the new battlefield. What we are witnessing in the world of web development and browsing is, at least, an interesting time. What was once a browser and some useful extras is quickly becoming something much deeper, and I guess you could call it a fully native AI ecosystem. Browsers are no longer just about display and navigation; nope, they are being reimagined as aides, collaborators, and even productivity powerhouses.

I have been playing around with some of the new AI browsers, and I have pretty much settled on one as my primary (for now). I used to browse on Brave Browser, but now I mostly use Comet by Perplexity AI. I’m also testing out ChatGPT Atlas, and others such as Zen Browser and Dia Browser.

In this article, I will walk you through:

Why AI browsers are becoming a major shift
My hands-on experience with the main players
What strengths they bring, and what risks we should be aware of
What this means for developers, power-users and the "regular" browser user

Why AI Browsers Are Becoming Something Big

The era of the Chrome browser with a static display, tabs, and navigation has been disrupted by tools that understand context, help you do things and speak to you like agents.

Here are some of the developments worth following:

Built-in AI personal assistants that summarise pages, highlight data, and compare open tabs. For example, Comet allows you to highlight any text and ask a question about it.
Browsers that are designed for workflows, not just websites. They can assist you in sending emails, organising tabs, and even making purchases and all powered by AI.
A new race of big tech actors creating "agentic browsers" (as opposed to just browsers with AI features). And Comet is "the AI browser Google wants."

It’s not just a question of "which browser do I use" but also, "of which known browser agent am I part".

On Twitter/X, a developer called Dominik Kundel created a viral post where he said, "With ChatGPT Atlas, every coding app is now a vibe coding app". And he showed a video demo.

You can see it here:

// Detect dark theme var iframe = document.getElementById('tweet-1980720031303716917-648'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1980720031303716917&theme=dark" }

My Hands-On Experience with the Main Players

Here’s how things have gone in real use and what I tried, what I switched to, and what I’m watching next.

Comet (Perplexity AI)

After years on Brave, I migrated to Comet. What drew me in was the fact that Comet starts as an AI browser (on top of Chromium) with extension and interface backward compatibility. It includes deep integration of Perplexity’s AI assistant, so not just a sidebar but context-aware interaction. In use, I found it pretty slick; you can highlight data and have the browser summarise multiple tabs or request it to go find insights across all open tabs.

Despite all of this, I believe that there are real risks which people have noted. For example, security analysis at Brave reveals that indirect prompt injection attacks (based on screenshots or hidden content) can seize control of agentic browsers like Comet.

They made a Twitter/X thread on it, which you can read here:

// Detect dark theme var iframe = document.getElementById('tweet-1980667345317286293-444'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1980667345317286293&theme=dark" }

ChatGPT Atlas (OpenAI)

This is OpenAI's entry into the AI browser space, released 21 October 2025. I have been experimenting with it. Obviously, it uses the OpenAI model ecosystem, with deep integration with ChatGPT workflows, and a big brand backing.

At this stage, I find that it's fresh, but not as mature as Comet on a day-to-day use basis, but it could be promising. I feel like if it had been released before Comet or even on the same day, it would have eaten into its market share.

Other Browsers like Zen and Dia

Zen Browser is another worth mentioning. It has been out for a while and has a decent following. Zen was even a top open source project on GitHub in 2025, which you can read about here:

// Detect dark theme var iframe = document.getElementById('tweet-1983296724920926681-630'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1983296724920926681&theme=dark" }

Dia Browser and others are also appearing. It’s still early days, but these are the signs that the browser market is shifting. Dia is essentially a successor to the Arc Browser, which was abandoned over a lack of community uptake and a high learning curve, plus technical debt. The switch to Dia was because it seemed like a good strategic move toward the future state of browsers, and also to address some issues in Arc.

What Strengths Do You Get, And What Needs Caution

Here’s a breakdown of what’s important and what you should keep your eyes on.

AI-first browsers are changing the way we work with the web. They are not just looking over your shoulder at specific tabs and URLs; they know what content you are viewing, so you can ask questions, summarise pages, and even compare info from different tabs. This context-enhanced approach provides a speed-up for workflows by automatically handling repetitive browsing functions of search, analysis and reason across sources. It also combines everything into one environment, so no toggling between your browser, an A.I. tool and a bunch of extensions. For Developers and power users, adopting early means they can influence the development of this evolving ecosystem and give them a competitive edge as the technologies reach a level of maturity.

But agentic, AI-powered browsers carry new risks. Security and privacy also begin to get tricky, as sneaky prompt injections tucked away in images or webpages can influence how an assistant reacts, something that’s been demonstrated by a recent Brave study. These systems also process far more contextual information, giving some people more reasons to worry about the data which is stored, accessed and the transparency of the terms. And although the potential is huge, the ecosystem is also young, with some instability and performance bottlenecks. So basically, deeper integration with certain AI models and vendors could result in lock-in, making it more difficult to remain long-term independent and flexible.

What This Means for Developers and Power Users

For developers like those on Dev.to, Medium, freeCodeCamp and social media, this change has a big upside:

New tooling mode: The browser is a part of your dev flow, not only to browse docs and GitHub, but reason + summarise + multi-tab cross-analyse
New extension/agent opportunities: If you create tools, agents or browser extensions, this is also a great field because it affects the design space when you build AI-native browser tools.
Mistakes of the past: We will do things in our browser history, instant summarisation, tab reasoning, maybe even multi-tab context features. Your applications might want to treat smarter clients.
The importance of a security-first mindset only increases: As we embed more AI agents into browsers, new routes for exploitation change. Developers must be ready for new attacks, especially if they are developing web apps being consumed by agentic clients.
Adoption and migrating concerns: In case you lead teams or recommend tooling, monitoring maturity and trade-offs of these browsers make sense before whole adoption.

Conclusion

AI browsers are more than hype; they are the real and huge shift in how we browse, search and interact with the web. For me, moving from Brave to Comet made a difference to my workflow, history-aware browsing and time to get things done. I’m also keeping a close eye on Atlas and the other AI browsers in development.

Regardless, as amazing a development as that is, it's also one that brings with it more responsibility. We should be aware of the security implications, data privacy and the new threat models which emerge when dealing with agentic browsing.

For developers or power users, this is a great time to play with new generations of browsers. They might end up influencing not just what you see on the web, but how developers and workers work online.

How Verdent Deck Supercharged My Workflow - Building Apps with Multiple AI Agents in Parallel

Andrew Baisden — Tue, 04 Nov 2025 11:31:19 +0000

AI coding tools have made a lot of progress over the years, as we have all seen. They have gone from simple autocomplete and snippet generators to something much closer to a teammate. A teammate who knows your codebase, understands your architecture and can actually contribute to it in a good way.

A few months back, I got early access to Verdent AI before its official release. It was still in beta at the time, and I was excited to give it a shot, especially since Verdent’s offering was unique:

The leading all-in-one coding agent for top-tier AI models — integrated, orchestrated, and fully unleashed. Achieved the highest SWE-bench Verified results among real production-level agents, including Claude-Code and Codex.

It almost sounded too good to be true. However, after trying Verdent Deck, I noticed that Verdent is not just another "AI code generator." Verdent is a platform specifically designed for real-world development, the kind that uses different branches, isolates features, and keeps your codebase perfectly polished, like version control.

What Makes Verdent Different?

Verdent takes a new approach to AI-assisted coding. Instead of relying on a single model, it combines multiple AI agents, each specialising in different strengths. Think of it as merging the versatility of Claude-class creativity with the precision of Codex-class reasoning.

Verdent is a totally new take on AI-assisted coding. Instead of relying on a single model, it uses several AI agents, each developed in its own specialisation. It’s as if we have combined Claude-class versatility and Codex-class precision.

The power of Verdent is in the agent's power to combine without overpowering. Verdent utilises git worktrees to develop exclusive branches designed for every AI-driven change. In practice, it means that there are no merge conflicts, no erased commits, and no ruined main branch. It is like operating a squad of AI devs in independent sandboxes, each safely adding content at the right time.

There are two main products:

Verdent for VS Code – A coding assistant that lives directly inside your editor, which is perfect for devs who prefer tight control.
Verdent Deck – A visual dashboard that lets you orchestrate multiple projects and agents at the same time, complete with task views, diffs, and documentation.

After using Verdent Deck, it completely changed how I approached multitasking and experimentation in my projects.

My Beta Experience with Verdent Deck

When I first joined the beta in August 2025, Verdent already felt pretty well polished for an early release.

Setup was fast, I hooked up my local projects and, after a few moments, Verdent detected my repo setup and active branches. It then loaded up what it refers to as "Decks", which are sandboxed workspaces where I could designate AI tasks or feature builds.

I could stack tasks instead of waiting for one to finish
I could run multiple apps or features in parallel, each in its own isolated branch
I could switch contexts easily thanks to git worktrees integration

The first impressions instantly worked for me. As someone who frequently has multiple different experiments or projects going on at the same time, this was a huge time-saver. No need to constantly switch contexts, no left behind broken parts, just clean, parallel progress.

Vibe-Coding with AI

I liked that Verdent Deck allows vibe coding. I was constantly in that flow state of experimentation, pursuing creative ideas wherever they led, all while keeping things organised. Trial and error became quick, cheap, and transparent. During the beta, I used Verdent Deck to spin up several tiny projects just to see what it could handle.

I built simple prototypes, tweaked features, and pushed updates, all while watching Verdent’s agents run multiple parts of the stack.

Each task came with:

A diff view showing exactly what Verdent changed
Inline reasoning explaining why it made each modification
Automatically updated docs for every function or component touched

The final example might not seem all that, but it proved a critical part of the power of multiple parallel backgrounds. Especially when you are juggling complex responsibilities, consistent documentation is crucial. Verdent wasn’t just coding; it was documenting its work as a teammate.

Here are some of the projects I worked on:

A personal CRM App:

A journal app:

A radar app:

From Beta to Full Launch

Fast-forward to today, and Verdent is out of beta, and it’s grown a lot since I first tried it.

The production version is faster and more stable, and feels more connected. Diff reviews are suddenly a much better experience, the dashboards are sleek, and the smart AI agents collaborate even more smoothly. You might barely notice it, but Verdent’s orchestration system now supports real-time cross-validation between agents.

When the AI suggests a change, another one can validate its logic before it’s set in the code. It’s as if we have implemented a built-in code review system where several AI's check each other. For developers, it means fewer regressions, fewer subtle logic errors, and a higher level of trust in the code you send.

Why Verdent Feels Like a Real Teammate

Some AI tools have stopped at "here’s some code." Verdent goes further because every change Verdent Deck proposes has a diff reasoning, and optionally, documentation updates, so you always know what and why something has changed. It is not just a matter of timing; it is a matter of confidence and situational awareness.

When you use Verdent Deck, it is like having a small dev team. Each agent is clever, independent, and smart enough and never breaks the main branch. Also, the code you receive is clean and ready for production, and you can expand the infrastructure and system logic. For people and small groups, this is a great advantage.

Conclusion

From the beta test period to working with the full release, my experiences with Verdent have convinced me that this is the future of AI building. Verdent Deck is more than an assistant. It is an AI building experience that tackles complexity, parallelises work, and encourages discipline while staying out of your way.

If you have ever wished that AI code tools could manage multiple projects, multiple agents, and zero conflicts, take a look at Verdent. My work on this platform feels like working with a team instead of with a tool.

Check it out: verdent.ai

9 Productivity Hacks - AI Tools That I'm Using in 2025

Andrew Baisden — Mon, 03 Nov 2025 18:06:47 +0000

In 2025, AI tools have made my workflow soooo much more productive by speeding up a lot of mundane tasks. Each day, they feel like an extension of my work and creative thoughts. Whether I am coding, researching or just trying to keep up to date with this never-ending stream of AI news, which keeps us all entertained and busy.

To keep my productivity on track and stay ahead, these 9 AI tools are the ones I use the most, almost every day:

1. Comet Browser - The AI Browser for Learning Fast

I was part of a select early group invited to try Perplexity's agents with the Comet browser. I was pretty impressed by how good the AI assistant was, as well as its ad-blocking features. When it was finally released to the public, Comet Browser quickly became my main browser.

It is built by Perplexity, which means that Perplexity Search is built in, so I can use my favourite AI search engine 24/7. However, the killer feature is that I can summarise YouTube videos and take out the key insights using Comet. This is an amazing feature because it allows you to speed watch videos, getting all the information you need, so sort of like binging a Netflix series, although you're not really watching, you're getting all the information, saving you from having to watch the whole video unless you want to.

It can feel like a cheat code if you just so happen to have a long watch list of saved videos; you no longer need to spend many hours watching something which might not be highly relevant. With Comet, I can summarise, gain insights, watch another video, and that is it.

So, if I am reading a book or researching a topic, I can open a dozen YouTube videos all at once, summarise them, and move on. There is no need for writing down notes or pausing the video, just quick learning. The AI assistant works everywhere, but if I need a standard search, I can switch back to Google at any moment. Of course, the AI assistant can do a lot more than that. I just scratched the surface. The key takeaway here is speed! Fast task completion all the time.

Try it now at https://www.perplexity.ai/comet

2. Cursor - Coding with an AI Teammate

With Cursor, I have finally found my new favourite editor when deep in code. The AI-assisted IDE, which is specifically built for developers, features the Cursor Tab, which is like gold. It is a context-aware, multi-line code suggestion UI that just somehow makes sense.

Write, refactor, explore a massive codebase, or whatever you throw at Cursor, it simply gets it. Also, Cursor integrates with Codex CLI, which means GPT-5, so I always have its power right in the editor. The newest version, 2.0, of Cursor makes it the number one IDE right now, in my view. Their blog is the best place to read about it and get updates on all new features. It is, probably, the closest thing you can find to a coding partner who is program-aware and knows your entire project.

Try it now at https://cursor.com/

3. Zed - The Rust-Powered Speed Machine

Zed is yet another AI code editor that I return to a lot. It’s built using Rust, so it’s extremely quick and lightweight. Even the largest projects open quickly. Zed also works with Codex CLI for GPT-5 powered coding, much like Cursor.

However, when I simply want a pure, focused coding experience, quick edits, or coding with no lag, I return to Zed. If Cursor is like coding alongside a friend, Zed feels like speeding around in a race car on your own. Both are excellent options, and it depends on your mood or desire when deciding which one to use.

Try it now at https://zed.dev/

4. Warp Terminal - AI Meets the Command Line

Using Warp felt like a leap forward when it comes to working on the command line. With its in-built AI agents and suggestions, instead of typing "how to do X in bash" to Google, I now ask Warp itself.

Want a git command? Docker error? Warp’s got you covered. It also explains what commands are, so you learn a ton while working! You use it as a mini IDE as it manages workflows, commands, and scripts all in one location. When you have used it, switching back to a regular terminal can feel like a downgrade, although there are caveats and exceptions.

Try it now at https://www.warp.dev/

5. Codex CLI - GPT-5 in Your Terminal

Codex CLI is another great tool in coding-inspired AI. Codex CLI is built for agentic workflows, allowing you to talk to GPT-5 directly through your terminal or editor extensions. Again, I use it both inside Cursor and Zed, and it’s just as practical as having a helpful assistant around: generating files, trying to reason about your code, automating some repetitive workloads.

It’s fast and flexible, its wait time and API calls are usually not that long, and you can pair or use only your so-called ML model to keep everything quick and straightforward. If you enjoy command-line tools and some automation, then Codex is top-tier right up there with Claude Code.

Try it now at https://developers.openai.com/codex/cli/

6. Grok - The AI Engine of X (Twitter)

Grok by xAI is virtually an AI sidekick for Twitter/X. I use it to keep up to date with the latest developments in tech, AI, and other trending topics; it is like a real-time AI data analyst ready to help whenever you need it.

It is even useful in brainstorming, generating images, and is probably the best at following real-time news. If I spot a trending topic and need more information, all I do is ask Grok for the latest data, and I get it right away. Grok is like a creator or dev living on X, ensuring that you always receive the latest information.

Try it now at https://grok.com/

7. ChatGPT - The All-Rounder

You probably figured this one out. ChatGPT once again is a big part of my productivity stack. I use it for research and brainstorming, code generation, and writing. It is the most efficient way to experiment with new things, troubleshoot code, or just relax.

Additionally, with the ChatGPT Atlas browser, it’s becoming a real all-in-one workspace, combining chat, the web, code, and image generation all in one location. The real strength of ChatGPT is how it integrates into your job, whether you are collaborative, technical, or a combination of the two.

Try it now at https://chatgpt.com/

8. Claude - The Calm, Contextual Thinker

ChatGPT is my all-around assistant; Claude is just as capable in a lot of areas and easily earns a spot on my list. For writing, deep research, or reasoning over long documents or technical content, Claude excels.

Claude Code is right up there alongside Codex, and Sonnet 4.5 is still a very capable coding model.

Try it now at https://claude.ai/

9. NotebookLM - Learning and Researching at Speed

For fast learning, I have a secret weapon. NotebookLM, which Google built, enables me to digest and connect information from various documents. As a result, I use it to study new technologies, analyse data, or brainstorm article ideas.

It is a form of having a personal tutor who can reference PDFs, make notes, and cross-reference web sources all in a few seconds. NotebookLM saves me a whole bunch of time, much like Comet, as I can summarise large swaths of information and, in this case, turn it into a podcast to listen to at my convenience.

Try it now at https://notebooklm.google/

Conclusion

AI tools are no longer optional as they are crucial to how I and many other people do work. You might notice that every single tool takes care of a distinct piece of the puzzle; learning quicker, coding smarter, researching deeper, or just staying updated without the unnecessary noise.

In 2025, the largest productivity hack isn’t going to be more hours; it will involve using the right AI tools to make your work easier.

Anima Playground vs. Figma Make - Choosing the Right Vibe-Coding Tool

Andrew Baisden — Thu, 24 Jul 2025 11:09:36 +0000

Converting a design into code used to be a lengthy process with lots of back and forth between design and development teams. The handoff process could create bottlenecks and slow down product creation, as the whole process was very manual and sometimes required trial and error and lots of thinking to see if it was viable and practical to build out a new feature or component. These days, the process is considerably less intensive and even more improved because of the sheer magnitude of vibe coding tools available on the market.

Vibe coding has revolutionised the way designers and developers work because now artificial intelligence can understand both your design and code files, making it a pretty straightforward process to generate working applications. Struggling over complex designs is now a thing of the past because AI is capable of turning static designs into working functional code.

In today's article, we are going to look at two of the leading design-to-code vibe coding platforms, which are Anima Playground and Figma Make. Both of them are designed to convert a Figma design into a fully coded application. Anima Playground is a fantastic external platform which has a Figma extension, whereas Figma Make is built into Figma.

This is a worthwhile practical comparison because choosing the wrong tool can result in a less-than-optimal workflow that requires a lot of hands-on work, which can cause unnecessary frustration. In this project, we will put both tools through the paces as we compare the same Figma design by using the same vibe-coded prompts. This will allow us to see how each platform handles everything, starting with the basic design and then converting it to a more complex interactive application. By the end of this article, it should be more obvious how these two platforms compare, making it easier to make an informed decision on which to use.

What Are Vibe-Coding Tools?

Vibe coding tools are essentially AI powered platforms that can understand design decisions and thinking processes through natural language prompts. This means that they are capable of transforming static designs into functional applications and no traditional coding is required. In traditional workflows a developer would manually build out a design by hand using code. AI powered workflows on the other hand use conversational language such as "make this section interactive" or "add a loading animation to this section". The AI would then analyse the visual as well as the users' prompt to generate the required code and this basically bridges the gap between the design and technical implementation.

What Are Anima Playground and Figma Make?

Anima Playground

Anima Playground is a design-to-code platform which is a powerful tool for converting Figma designs into full functional apps. Anima allows users to import any Figma design and then use natural language prompts for adding the interaction, logic and more advanced functionality. The platform has been in Beta for a while and, is capable of generating clean and production-ready code for the popular JavaScript framework React.

Figma Make

Figma Make is basically Figma's official AI-powered design to code solution which is built into the Figma ecosystem as part of their AI implementation. The tool can convert static designs and Figma designs into code which is a great way for designers to create quick prototypes which can be handed off to developers. As of writing Figma Make is still in early Beta and is not available on the free Starter plan. It's only accessible via the Full seat paid plan.

Working On Our Figma Project

The design which we will be working on in this project is for a Movie Database website like IMDB.

You can take a look at the design below:

The design is fairly simple, and uses Auto Layout and components to make the layout easier to manage. It's not that complex, so it should be pretty easy to vibe code.

Ok, before we start vibe coding, the first step will be to quickly run through the setup for both Anima Playground and Figma Make so we can see how they convert a Figma design into code.

Anima Design To Code Workflow

The first step is to install the Anima - Figma to Code React Dev Mode plugin for Figma. Once that is done you need to switch to Dev Mode and then you should see the Anima Plugin somewhere on the right. Clicking on the button will start the design-to-code conversion process.

After the conversion process has been completed, you should see an Open Playground button in the right sidebar. Clicking it should take you to the Anima platform, which should open in a web browser window.

The Anima Platform will start to convert the design to code as you can see here:

You should now see the completed design created using Vite if the server does not start automatically you can use the usual run command to start the server which is npm run dev.

As you can see the code more or less matches the design which is not too bad for a first attempt. There are a few areas which could do with a bit of spacing but those are minor fixes and we haven't even started to write any prompts yet so its a good first start. Its worth mentioning that it's not currently responsive and none of the logic or functionality works yet, which is ok because the first step is design anyway.

And here is a snapshot of what the codebase looks like:

Anima is using the Vite framework to build a React project.

Here we can see the app in action:

Figma Make Design To Code Workflow

The Figma Make setup is slightly different because its built into Figma. It's still in early Beta so the setup might change a little bit in the future. To begin with open a New file in Figma and click on the Make button which is at the end on the right as shown here:

You might see a getting started screen, especially if this is your first time using the tool:

You should now see the Figma Make interface screen.

In the bottom left-hand corner there is a prompt box for writing your commands and attaching media. You need to go to your Figma design file for your website or application, select it and then copy it. This can be done by right-clicking the menu and selecting copy or using the usual keyboard shortcuts for copying. Take the copied file data and paste it into the prompt box and it should attach as an image. Alternatively, you could export the design as an image and then attach it manually.

Lastly, we just have to tell Figma Make to convert the design into a website. I used this prompt command to do so: Build a website based on this design.

And this was the website Figma Make created after the prompt.

Figma Make did an ok job of converting the design however the hero image is clearly broken and the movie list is partly inside of its container. Also Figma Make hallucinated and added a second row of movies which was not part of the original design. Its not all bad news though because the website is almost fully responsive right from the start and surprisingly the search box and the checklist on the left work. So that's pretty impressive despite the design not being quite accurate.

And here is a snapshot of what the codebase looks like:

Figma Make appears to be using some custom Next.js code to create a React codebase.

Here we can see the app in action:

Head-to-Head Comparison

Now let's do a head-to-head and with some vibe coding tests, to see how both platforms compare when we make changes.

Test 1: Adding a new section

Prompt Used

Build a streaming network section at the bottom in a new row, using these logos and add a short description of each streaming network and how much content is available on the platform.

Anima Playground Results

The first image shows the initial prompt with the logos attached for Netflix, Amazon Prime Video and Disney+:

The second image shows the completed design after the prompt:

Figma Make Results

The first image has our prompt like before, with the logos for Netflix, Amazon Prime Video and Disney+:

The second image shows the updated design with the new section:

Verdict

Winner: Anima 🏆

Anima wins this first round because it's possible to attach multiple images as part of the prompt. I'm not sure what the limit is, but I was able to attach at least 6 images. This is important because I wanted to add more than 3 streaming networks, but was limited to 3 with Figma Make, so I had to settle for this design. I suppose I could have added more logos with a second prompt, but regardless, it would have shown that Anima is slightly more capable in this area. Both designs do look good, though, and follow the prompt, although the Anima design is slightly better overall because the content is not outside of the container.

Test 2: Changing the style

Prompt Used

Change the font type of the website to Roboto Condensed and the background colour to #0A0606

Anima Playground Results

In this image we can see how the website has been updated with a different background colour and font style:

Figma Make Results

This is how our website looks in Figma Make after the new updates:

Verdict

Winner: Draw 🤝

It's a draw, although I should mention that Anima Playground changed the background colour for the header, and Figma Make left it the same. Whether the header background can be considered part of the overall background for the website is subjective I guess.

Test 3: Modifying the layout

Prompt Used

Turn the 5-column grid section with the movies into a 4-column grid and add two new rows of movies underneath.

Anima Playground Results

This is how our website looks after the update:

Figma Make Results

And this is how our website looks in Figma Make after the update:

Verdict

Winner: Anima 🏆

Anima gets the win here because it more closely followed the original prompt. They both had a slightly different approach to this prompt. Anima Playground is duplicating the content and creating new rows, which is fine because the design is correct and follows the prompt.

Figma Make created too many rows because it was hallucinating at the start when it created more content than needed, which was not part of the original design. So it has created two rows for every one row I requested. It did manage to find images for the new content though and they are sized well although not all of the movies have images.

Test 4: Updating the CTA section

Prompts Used

Prompt 1

Update the text in the Superman hero section at the top to this:

"Superman is faced with the profound challenge of reconciling two vastly different parts of himself—his alien heritage as the last son of Krypton and his human upbringing as Clark Kent, a mild-mannered reporter raised in the heartland of Kansas. While he strives to embody the timeless ideals of truth, justice, and the best of humanity, he finds himself increasingly at odds with a modern world that regards these values as naïve or antiquated. As society grows more cynical and divided, Superman must navigate the tension between who he is, where he comes from, and what he stands for—ultimately questioning whether there’s still a place for a hero who believes in hope, compassion, and doing what’s right, no matter the cost."

Make the buttons in the hero section rectangles with flat edges instead of rounded corners, and move all of the content to the right-hand side of the hero image.

Prompt 2

Replace the hero image with this one attached

Anima Playground Results

I actually had to use two prompts because the first time Anima did not make the changes for some reason:

After making Anima aware that the changes were not visible, it noticed the error and fixed them in the second attempt:

In the final prompt, I got Anima to change the image in the hero:

Figma Make Results

Here is how our hero image looks after the first prompt:

And this is what it looks like after the second prompt:

Verdict

Winner: Anima 🏆

So first, Anima slightly changed the design with some hallucination and added buttons for Watch Now and Add to Watchlist. I do think it's an improvement because moving the content to the right meant that it was now covering Superman's face which is why I had a second prompt to change the image. Anima seperated the image and the content which was a good fix, I might have made eventually.

Figma Make followed the prompt more accurately this time, but the hero image is still broken, whereas it's been fine in Anima since the beginning. Both were successful in changing the hero image, though.

In the final round, I will just give the edge to Anima because it's clear to see that the website is much cleaner and closer to a final design. Sure, there might be duplicated content, but Anima did follow the prompt, whereas Figma Make hallucinated more and focused more on functionality instead of getting the code to match the design, which is the first step. More work and vibe coding would be required to get the coded design to the same level as Anima.

Figma Make did do a good job with my prompt for the hero section, though, but it does not change the fact that the hero section and overall design look more broken when compared to Anima.

We can see the final design for both platforms below:

The website created in Anima looks the best visually, in my opinion. The design is much cleaner and none of the elements appear to be broken.

The website created in Figma Make has a broken hero image, hallucinated content and missing images for some movie titles. The header has a different background colour to the one in the Anima build. This is a bit subjective because I did say change the background colour but it can be debated that this included the header too. The content is still broken and falls out of the containers when the page scrolls.

Despite these errors Figma Make did manage to make the website responsive and the functionality was working for the list and search bar. However, this initial phase of building was for the design; the functionality would have come next, so it still loses a few points because more vibe coding would be needed to resolve the broken design.

As of writing, Anima has a free option as well as Pro, Business and Enterprise plans. Figma Make is currently in beta and not available on the free starter plan. If you want to use Figma Make, you will have to pay for the Full seat plan. Either way you need to purchase at the very least a Figma Dev seat plan so that you can use the Dev Mode, which is required for using most Figma plugins anyway.

In terms of workflow integration both tools are a fairly good choice because they can convert designs to code and fairly well. Performance is slightly better in Anima because Figma Make has been in Beta for a shorter time whereas the Anima Platform is more stable.

Anima Playground is also available on the web alongside the Figma plugin whereas Figma Make must be used inside of the Figma platform.

If I had to use one of these tools for a real-life project, I would choose Anima because the platform has been around for longer and is far more stable and feature-rich. Like being able to push your codebase to a GIT repository and the fact that the codebase is more production-ready. I also like the fact that you can attach a lot more images alongside your prompts, which means it would take fewer actions to get work done.

My overall thoughts on my experience after using both platforms are that productivity can be significantly increased when using Vibe coding tools, and this is good because it means more work can be accomplished in a much shorter time frame. Both the design and codebase are easily accessible, so designers and programmers can continue doing what they do best without having to change context.

Conclusion

The design to code vibe coding space is hot and Anima and Figma Make are two great platforms to use. At this point in time Anima Playground feels like a more polished product as it has been in the beta phase longer and the tool just does a much better job of following prompts and getting a codebase to match a Figma design.

Anima Playground is right up there as one of the best vibe coding platforms and easily competes with some of the other names, like Bolt.new, Lovable, Replit and v0 by Vercel.

Designing and Building an Application with Anima, Figma, and React

Andrew Baisden — Mon, 17 Mar 2025 12:29:38 +0000

The tech industry moves at a rapid pace with new tools arriving all the time. I was fortunate enough to have the opportunity to try out a cool new tool by Anima, the design-to-code platform. In this guide, I'll document my journey from designing a Habit Tracker in Figma to deploying it online using Anima, React, and Netlify. We'll cover the full workflow—design, build, and deployment—showcasing how Anima converts Figma designs into a React project.

This is what the original Figma design looks like:

And this is what the final design looked like in Anima:

As you can see, they almost look identical. It's worth mentioning that I decided to make some changes, improvements and refinements to the original design, when going through the build process with Anima. Like adding a button to check off habits when they are completed, which was missing before. I could have used more prompts to improve the final build significantly, but this is already enough to showcase how good Anima is at converting a design into React code.

You can find the codebase and a live demo of the app online here https://github.com/andrewbaisden/habit-tracker-app

So if you are a designer aiming to boost your prototype skills. Or a developer looking for an efficient way to build a modern application this tutorial will show you how using a tool like Anima can level up your game.

What is Anima?

Anima is an AI-powered platform which is capable of doing design-to-code, and is available as a plugin for Figma. This basically means that you can create a design. And then turn that design into code automatically using artificial intelligence. This can be a very effective way to convert designs and prototypes into programming code which a developer can use straight away.

For example a designer could design some components in Figma. These design components can then automatically be converted into code which a developer can integrate into their application straightaway. This can drastically reduce the time that is required to design and build new features. Anima is a very effective coding assistant. Developers can build features faster. Designers can be sure that their design is being built accurately.

Building a Habit Track App with Anima

The technical stack is as follows:

Figma (Design tool)
Anima (AI-powered design-to-code platform and Figma plugin)

Anima builds a React project using Vite. This was my first experience of using Anima so I will document and go through most of the prompts which I used for building this app. I think this is also a good introduction and proof of concept of how "prompt engineering" or "chain prompting" can be and how effective it is at building applications from an existing design.

Converting a design into code

I will now go through the process of building an application using Anima for the first time. I had no prior experience so everything is real and unscripted. The mistakes I made and what I learned and how I finally learned how to use the platform. To begin with, I designed the Habit Tracker App myself using Figma which took a day or so and then I used the Anima plugin to convert the design into React code.

Converting the design into code required zero user prompts as Anima was able to do it all seamlessly. I did use two user prompts to make some refinements at the start though. In total it took me around 17 user prompts to get to what I believed was a good Minimum Viable Product (MVP). This inlcuded adding features, bug fixes, refinements and much more. It could have taken fewer or more prompts it all depends on your choices.

Before we begin I should mention that Figma needs to be in Dev Mode, not Design Mode which is the default. The Anima plugin requires Dev Mode to convert the design into code. Dev Mode requires a paid Figma Professional Team account. You can use the menu bar at the bottom of your Figma design file to switch to Dev Mode and then you should be able to use the Anima plugin to convert your design into code as you can see here. By the way when you are designing your application in Figma its best practice to use components as it makes building much more straightforward and falls in line with component driven development that we are all used to in any JavaScript framework project like React:

I created one big component for all of the smaller components in the app, and Anima generated a React codebase which included TypeScript and Tailwind CSS files for the whole app. The code was generated in the right sidebar window in Figma, and took less than 1 minute. There were also two buttons at the bottom of the sidebar, one for opening in the playground and one to download selection.

I chose to open in the playground and the React project and codebase opened in a new web browser window on the Anima platform as you can see here. On the left is the text box that gives us the power to write prompts to iterate over the build, make changes etc...

Anima built the project and codebase for the app and then created a running server which showed the app working in the browser and it did this all in one go which was impressive! Usually this would take a developer a few hours or days to setup the project arcitecture, build all of the seperate components, design the page, do testing etc... But Anima managed to accomplish the building part of this task in seconds!

However I did notice that the status component was missing the picture for a user's image. I also noticed that the Repeat frequency selection list was missing from the habit component. Considering that Anima had managed to get this far without any user prompts was already a fantastic sight to see. My design was not perfect from the start I could have cleaned up the components but it was nice to know that Anima was still able to build the app to this extent. I imagine that most designs could be built with Anima with ease. I knew that the Anima plugin could generate the code for any component so this gave me the perfect opportunity to see how well it could adapt and fix missing elements in the design.

So I used the Anima plugin to generate only the code for the missing components which inluded the TypeScript and Tailwind CSS files. Then I copied and pasted the code for the Repeat frequency component, into the prompt window on the left hand side of the Anina pltaform, with my prompt description of what I needed to be done. Anima rebuilt the app with the new changes and sucesffuly updated with the missing components!

These were the two prompts I used to resolve those issues:

Anima Prompt 1

Anima Prompt 2

And this is what the design looked like after these prompts:

I'm not too bothered about the image being broken at this stage because I could give Anima a link to the image online. Also I know that manually downloading the image and adding it to the project will probably fix the broken image issue. What important at this stage is just getting the code to match the design.

Having knowledge of both design and development is highly beneficial when working with the Anima plugin. Knowing the right technical lingo to use as a designer and developer when writing prompts can be very helpful. The original design does not have white borders around the components, whereas the one created with Anima does. I could change it but I think it looks okay for now, so I decided to leave it and focus on other areas.

The initial basic design is at a very good point after two prompts and I have only spent a few minutes working on this project. Anima definitly makes a developers job much easier and faster, it could have taken a few hours or a day to get this far without using Anima. So my starting goal has already been accomplised thanks to Anima, the design has succesfully being converted into a React codebase.

So that was pretty easy right? The onboarding went fairly smoothly and did not require that much technical setup. Lets quickly go over the steps it took to convert a design into code using Anima:

Design your app in Figma
Switch your Figma file into Dev Mode
Use the Anima plugin to convert the design into code
Open the codebase in the Anima Playground
Wait for the app to compile, build and run in the browser

In the next section I will take things much further by using chain prompting to add new features and fix bugs which is exactly the type of work that a team would be doing when working on a project of this type. With each individual given various Jira tickets to work on. With Anima all of this can be achieved with little hassle.

Using chain prompting as a prompt engineer

Prompt engineering is essentially the process of writing instructions as a way to get the best results when working with an AI model or tool in this case, Anima. Ok so we have a starting point with the design, the next phase we will be adding functionailty, fixing bugs and improving the design. The next issues to work on was making the checkmarks green like in the design, ensuring that the progress bars in the profile component had colours and doing some alignment fixes for the habits. The following prompts fixed those issues:

Anima Prompt 3

Anima Prompt 4

Anima Prompt 5

The design then looked like this after the changes:

As you can see, the calendar is now too big for its container. The next 4 prompts fixed those issues and also better aligned the red cross delete button:

Anima Prompt 6

Anima Prompt 7

Anima Prompt 8

After prompt eight, the delete button was put outside the row component with the habit data, which was incorrect because I wanted it inside the white border. However, the positioning is acceptable for now because I do not think that it ruins the design and might be ideal because it is not in the same space as the calendar widget.

Working on this app has made me aware that prompt engineering is likely to become a legitimate skill if it has not already. Getting designers and developers to iterate a design or some project code with various prompts. It can create a very good starting point or even get you close to the final design. For areas where the AI fails to get the desired result, you can manually take over and do the design or work on the codebase as normal. The key bonus here is that the AI did a significant amount of the work, and you only needed to work on a few fixes to get the desired result. That's a lot of time saved. What used to take days or weeks can now be done in a few hours.

With the design phase more or less completed to an acceptable standard, I decided that it was time to write the business logic for adding and removing habits, which is a major feature of this app. The following prompts accomplished this task:

Anima Prompt 9

Anima Prompt 10

Anima Prompt 11

The application now made it to this stage after these new changes:

As you can see, Anima successfully implemented streak management functionality. I wanted to add logic for tracking streaks because it was hardcoded. Anima went a step further and added working streak management and was clever enough to add a check button next to the delete cross button.

Streaks also now start at zero and you can add and remove habits. The application is coming along well, there is just one big feature left to resolve. Getting the habit calendar to work, the streak counters and also the profile section which has gamification. The upcoming prompts got all of these features working:

Anima Prompt 12

Anima Prompt 13

Anima Prompt 14

Anima Prompt 15

After these prompts, the habit tracker app reached this phase:

The app is looking good and has basic functionality. Earlier in one of the builds I did notice a bug, though. You could toggle the completed habit check button on and off, and it kept updating the streak, which I guess was okay, because the app currently had no way to track real times or dates. I was thinking that the day-tracking circles in the habit should probably reset after 7 days to reflect a whole week instead of filling up and then staying the same. These bugs seem to be resolved now, though.

After Anima Prompt 12, the logic seems to be working for the counter, and the days, although other than physically waiting for the day to change, the only other way to see if it is truly working that I can think of right now would be to write some logic and maybe build a component for test purposes to simulate day changes for the app so I can see it in action. Prompt engineering with iteration and refinement is a good example of how humans can work with AI.

Okay, lastly, I want the title in the profile component to change depending on what level the user is at. And to also add to the gamification structure. I used two prompts to achieve this goal:

Anima Prompt 16

Anima Prompt 17

I could continue iterating forever, making improvements, changes and adding new features, but I think in its current state, it's good enough for a basic Minimum Viable Product (MVP). There are lots of feature improvements and likely bug fixes.

Some improvements that could be made to the app with further prompts include:

Making it fully responsive
Adding error handling
Persistence state/data for the habits like a database or local storage
Improving the gamification
The ability to edit and update habit names
Multiplayer
Being able to change a profile picture or a profile picture that changes based on level
A leaderboard to compare with other users
Charts and statistics data
Export, import and backup data
More pages/screens for additional features

The list goes on, and with each new feature, it turns from a simple app into a SaaS/PaaS, but regardless, this has been a good introduction to using Anima for app building.

The final step is deployment to Netlify which is quite easy and if your an experienced developer you have no doubt deployed many apps there already. If its your first time this guide on A Step-by-Step Guide: Deploying on Netlify should be very helpful.

Conclusion

In this tutorial, we walked through the process of building an application using Anima. We used prompt engineering to create an application which was fully functional and required little manual intervention from a developer. Anima was able to build the design straight from a Figma file in a very short space of time with fairly high accuracy. If anything, this should hopefully convince many developers to improve their design skills and learn how to use Figma because this will definitely help them to have more diverse skills and get more job opportunities.

AI continues to surprise and show off its capabilities, and Anima is right up there with the best design-to-code and app-building platforms out there now. With new LLMs like DeepSeek R1, o3-mini, Gemini 2.0 Flash, Grok 3 and the reliable Claude 3.5 Sonnet, which has been consistently reliable for coding. We truly live in a great time where dreams can be realised much faster.

Stay up to date with tech, programming, productivity, and AI

If you enjoyed these articles, connect and follow me across social media, where I share content related to all of these topics 🔥

12 cool open-source projects worth checking out in 2025

Andrew Baisden — Sat, 08 Mar 2025 15:27:13 +0000

Open-source projects not only inspire us to create our best work but also give us the capability to build things seamlessly, which would otherwise be much more challenging on our own. Innovative tools are emerging to address the most demanding challenges facing developers and businesses today. As online worlds become increasingly advanced, the right technological solutions can mean the difference between simple survival and real long-term success.

In this article, we will review a curated list of 12 cool open-source projects and highlight the incredible tools they offer. These tools revolutionise workflows and redefine the way teams create, analyse, and optimise their digital products. From AI platforms to advanced security systems, these tools offer strategic advantages that can dramatically reduce project timelines and uncover more sophisticated levels of operational efficiency.

Our carefully selected lineup provides insights into tools that enable:

Open-Source Innovation and Flexibility
Data Intelligence and Analytics
Security and Transparency
Workflow Automation and Efficiency
Cross-Disciplinary Collaboration
Scalable and Adaptive Infrastructure

So, start-ups looking to prototype quickly or established businesses looking to maximise can make the best use of these tools, which are at the forefront of technological innovation. They can be a great addition to any project that you are working on.

1. LangChain

A framework designed to simplify the development of applications powered by language models, leading to the creation of complex, multi-step workflows.

Website link: LangChain

2. CrewAI

CrewAI is an open-source Python environment that manages role-playing autonomous AI agents to bring about collaborative intelligence to tackle complex tasks.

Website link: CrewAI

3. Agno

Agno is an AI agent platform with pre-packaged tools and capabilities, allowing developers to develop AI assistants utilising their preferred large language models quickly.

Website link: Agno

4. AutoGen

AutoGen, designed by Microsoft, is an open-source system that develops multi-agent systems with conversation agents to implement sophisticated problem-solving and workflow automation.

Website link: AutoGen

5. PostHog

PostHog is an open-source product analytics platform that helps companies understand user behaviour through event tracking, feature flags, and session recording.

Website link: PostHog

6. Astro

Astro is a modern static site generator that allows developers to build fast, content-rich websites with minimal configuration, supporting multiple frontend frameworks via dynamic islands.

Website link: Astro

7. DuckDB

DuckDB is an in-process SQL OLAP database management system optimised for analytical query workloads designed to support efficient data analysis.

Website link: DuckDB

8. Supabase

An open-source backend-as-a-service platform that provides developers with a suite of tools to build scalable applications, including a real-time database and authentication services.

Website link: Supabase

9. Sigstore

A public good service that offers digital signing and verification of software artefacts, enhancing security and trust in software supply chains.

Website link: Sigstore

10. OpenTelemetry

An open-source project that provides standardised APIs, libraries, agents, and instrumentation to enable observability in software systems through metrics, traces, and logs.

Website link: OpenTelemetry

11. Penpot

Penpot is an open-source design and prototyping platform aimed at creating collaboration between designers and developers with SVG-based assets.

Website link: Penpot

12. DocuSeal

A fast, feature-rich tool for online document signing that works everywhere is available. It also has many different integrations.

Website link: DocuSeal

Conclusion

In short, the software highlighted herein is some of the most advanced and powerful options available for businesses and developers to leverage today. From AI-driven automation platforms to powerful analytics and database systems, these solutions deliver the flexibility and efficiency necessary to solve a number of challenges. By integrating these into your workflow, you can automate development, increase security, optimise user experiences, and ultimately drive growth. With technology changing on a daily basis, staying on top of such tools can allow you to be one step ahead of the curve and develop the next generation of apps with relative ease.

Stay up to date with tech, programming, productivity, and AI

If you enjoyed these articles, connect and follow me across social media, where I share content related to all of these topics 🔥

16 AI-powered tools for building your next project

Andrew Baisden — Fri, 07 Mar 2025 13:30:16 +0000

Developing applications has never been simpler because of the growth of AI-based and no-code/low-code development platforms. Developers trying to speed up the process of building or beginners with zero coding skills can now use these types of platforms as they give us the ability to build a minimum viable product (MVP) quickly. They are beneficial, as they provide easy-to-use solutions for building web applications, mobile applications, and automation workflows. The bar to coding has been reduced significantly because now we can use AI-assisted coding software like GitHub Copilot and IDEs such as Windsurf and Cursor, as well as the usual no-code coders like Bubble and Softr.

In this article, I will cover some of the most widely used options available to developers. These options provide us with some of the most effective tools for turning ideas into reality with as little hassle as possible.

AI & No-Code/Low-Code Development Tools

1. Windsurf

An AI-powered collaborative development platform of the future that simplifies application building, testing, and deployment. Windsurf is an IDE which brings real-time collaboration together with intelligent code suggestions, enabling developers to work seamlessly, either in the same room or across the globe.

Windsurf has built-in AI suggestions, auto-debugging, and one-click cloud deployment, which reduces friction in the development process, making ideas production-ready applications with greater ease. Ideal for groups wanting to streamline productivity and fast-track software deployment.

Website link: Windsurf

2. Cursor

An AI-powered code editor that supports various AI LLMs to help developers in coding, debugging, and optimising code better. Cursor enhances the coding experience as it has intelligent autocompletion, suggestions based on context, and real-time explanations, reducing the time required for debugging and research.

Cursor's native debugging, refactoring capabilities, and direct integration allow developers to focus on problem-solving rather than on syntax or implementation problems. So, it is ideally suited for both learners and experienced coders who want to enhance their workflow.

Website link: Cursor

3. VS Code + GitHub Copilot

A high-performance code editor with advanced features combined with an AI-assisted coding companion to increase developer productivity. VS Code provides a lightweight but highly customisable development platform with extensive language support, debugging, and an enormous extension ecosystem.

GitHub Copilot is embedded directly within VS Code to deliver intelligent code completions, suggest entire functions, and automate time-consuming tasks. It can learn from context and best practices, allowing developers to write cleaner, more efficient code faster. This makes it a must-have tool for individual developers and developer teams working on complex projects.

Website link: VS Code + GitHub Copilot

4. Bolt .new

A lightweight, fast online code editor designed for developers who require an easy way to prototype concepts, test code, and share snippets with ease. With a minimalistic interface and instant run, Bolt.new is compatible with different programming languages, allowing for quick testing without having to set up a complete development environment.

So, if you are brainstorming an algorithm, debugging a short script, or working with others, Bolt.new offers a pain-free experience that is accessible from any browser.

Website link: Bolt .new

5. Lovable

The Lovable platform is a no-code, AI-powered app builder that lets people build digital applications quickly without a technical background. Its user-friendly drag-and-drop interface, AI-powered design recommendations, and automated backend make the development process easy.

Basically, this means that it's possible to develop all kinds of apps, from web apps to mobile apps and interactive prototypes. Entrepreneurs, designers, and businesses can bring their ideas to life faster, which leads to a much greater reduction in development times, costs, and technical barriers. All of this makes Lovable a well-rounded solution for anyone who wants to transform ideas into complete applications with ease.

Website link: Lovable

6. Marblism

A well-crafted AI-driven platform that makes application development and deployment easy with less coding. Marblism uses artificial intelligence to automate mundane development work, optimise code performance, and provide smart suggestions, allowing developers to focus on innovation rather than non-essential problems.

Marblism has a straightforward interface, native deployment tools, and seamless integrations. It assists developers, startups, and organisations in bringing their ideas to market faster, be it web apps, mobile apps, or enterprise solutions they are creating.

Website link: Marblism

7. V0.dev

An AI platform that translates Figma designs into production-quality React components with Tailwind CSS. V0.dev speeds up the design-to-code cycle by translating clean, responsive, and customisable code automatically, saving front-end manual implementation time.

So, suppose you are a designer looking to bring your vision to life or a developer looking to speed up UI development. In that case, V0.dev bridges the gap between design and code, allowing the production of sophisticated, high-quality React apps like never before.

Website link: V0.dev

8. Betty Blocks

Betty Blocks is a cutting-edge low-code platform that makes it simple for businesses to create enterprise-level apps with minimal coding knowledge. Betty Blocks ensures that developers and non-technical users can build scalable, secure, and customisable apps with a visual development platform.

The platform simplifies digital transformation, reduces time to market, and decreases costs through drag-and-drop, reusable blocks, and pre-built integrations. Whether you're working on an automated workflow, modernising a legacy project, or building new software, using the Betty Blocks platform makes the process more flexible. This is good because it gives you better control, which is needed to turn ideas into minimal viable projects quickly.

Website link: Betty Blocks

9. Bubble

Bubble is one of the leading no-code platforms. It enables users to build fully interactive web applications graphically without writing a line of code. It comes with a drag-and-drop editor, a strong workflow engine, and extensive integrations to help users build everything from simple prototypes to intricate, scalable applications.

With in-built database management, responsiveness, and apps deployed instantly, Bubble allows startups, businesses, and entrepreneurs to bring their dreams to life simply and quickly without the limitations of conventional programming.

Website link: Bubble

10. Zapier Interfaces

A no-code app that allows the user to design their personalised apps and workflows with little work, linking straight to thousands of services through Zapier's powerful automation platform. Through Zapier Interfaces, the user can create personalised applications by visually designing forms, dashboards, and interactive components, along with automating processes on other platforms.

From processing information to triggering actions or integrating third-party services, this app makes it easier for non-tech users to automate and streamline processes without coding, increasing productivity and improving efficiency in teams.

Website link: Zapier Interfaces

11. Softr

Softr is basically a no-code platform which gives users the power to transform Airtable and Google Sheets into dynamic, robust web applications, client portals, and internal tools without coding. With Softr's drag-and-drop editor, users can create custom, responsive apps that are deeply integrated with their data sources.

This means that if you are building a client portal, internal dashboard, or workflow automation app, Softr provides the flexibility to turn plain spreadsheets into full-fledged web apps. With authentication, collaboration, and design functionality built-in, Softr lets companies get professional-grade tools up and running quickly and easily.

Website link: Softr

12. Glide

Glide is a no-code platform for building apps from spreadsheets with no programming required. The Glide platform allows you to transform Google Sheets data into interactive apps in minutes, with an intuitive drag-and-drop interface to build understandable, easy-to-customize applications.

So, teams that are creating a mobile app, client portal, or product catalogue can use Glide to create, maintain, and deploy apps at speed. With its specialised capabilities like data syncing, user authentication, and custom workflows, Glide allows users to take their spreadsheet data and turn it into fast, scalable applications within minutes.

Website link: Glide

13. OutSystems

The top low-code platform for building stable, enterprise-level applications with performance, security, and scalability first. OutSystems gives businesses the ability to rapidly develop, deploy, and manage complex applications with a visual development environment without needing a large amount of code.

With better integrations, reusable assets, and strong cloud deployment, OutSystems enables companies to accelerate digital transformation, simplify collaboration, and innovate at scale. No matter if you are developing internal tools, customer applications, or enterprise-level solutions, OutSystems makes sure that applications scale securely and effectively across systems and global teams.

Website link: OutSystems

14. Tempolabs

Tempolabs is an AI-based no-code automation platform that streamlines workflows and enhances processes with less coding. It uses high-level AI functionalities to automate repetitive tasks, enhance decision-making, and integrate varied systems without making it difficult to use, as it has a no-code interface.

With personalised workflows, real-time data processing, and broad integration, Tempolabs allows teams to manage vital tasks with less manual intervention. It is perfect for businesses that want to enhance efficiency, accelerate processes, and improve output without investing in extensive technical expertise.

Website link: Tempolabs

15. FlutterFlow

An up-to-date low-code platform that supports the development of mobile apps using Flutter, with drag-and-drop and built-in AI support. FlutterFlow allows both technical and non-technical users to create beautiful, responsive mobile apps without the need to be an expert programmer.

There is a design UI for creating designs, live previewing, and seamless Firebase integration. FlutterFlow simplifies the process of developing apps with full customisation and scalability. The platform also uses AI to help drive app-building tasks and automated workflows, making it the optimal choice for building high-quality mobile apps effectively and quickly.

Website link: FlutterFlow

16. AI SmartCube

A modern solution that takes advantage of the strength, of AI to create, build, and refine applications, providing companies with automation and performance boost capabilities. AI SmartCube streamlines the application development process through automated routine work, suggesting improvement and optimising proceits no-code interface makes it easy to useity.

Better AI-based insights, real-time performance monitoring, and seamless integrations allow companies to deploy and scale applications while reducing manual effort quickly. To speed up internal tools, customer-facing mobile apps, or enterprise apps, AI SmartCube helps organisations accelerate digital transformation and drive growth at minimum technology complexity.

Website link: AI SmartCube

Conclusion

No-code/low-code and AI-driven development platforms are transforming the application development process, making it more accessible, productive, and collaborative. From using AI-powered coding assistants and automating processes to creating apps without writing any code at all, such platforms enable developers of any proficiency to build disruptive digital products. Because technology is ever-evolving, using these tools can keep you ahead of the curve, streamline your process, and bring your ideas to life faster than ever before.

Stay up to date with tech, programming, productivity, and AI

If you enjoyed these articles, connect and follow me across social media, where I share content related to all of these topics 🔥