Mert

The Problem With AI Coding Tools

You’ve tried Copilot. Maybe Cursor. Perhaps Claude Code. And somewhere along the way, you’ve probably felt that disconnect—the AI writes code for you, but it doesn’t quite get what you’re building.

The result? You spend more time correcting AI-generated code than you would have spent writing it yourself. Or worse, you end up with a codebase that works but nobody—including you—fully understands.

BMAD-Method changes this paradigm entirely.

What is BMAD-Method?

BMAD stands for Breakthrough Method of Agile AI-Driven Development. Unlike traditional AI coding tools that do the thinking for you, BMAD positions AI as a collaborative partner that guides you through structured processes to bring out your best thinking.

Think of it like this: Instead of an AI that writes your code, you get a team of 12+ specialized AI agents who act as expert consultants—a Product Manager who helps you define requirements, an Architect who designs your system, a Developer who implements with you, and a Scrum Master who keeps everything on track.

“Traditional AI tools produce average results because they do the thinking for you. BMad agents guide you through structured processes to bring out your best thinking in partnership with the AI.”

The Philosophy: Scale-Domain-Adaptive Intelligence

One of BMAD’s most powerful concepts is Scale-Domain-Adaptive intelligence. What does this mean practically?

Automatic Complexity Detection

BMAD analyzes your project and adapts its approach accordingly:

• Bug fix? Use Quick Flow—3 commands and you’re done
• Simple feature? Tech-spec to implementation in 30 minutes
• SaaS platform? Full planning with PRD, architecture, epics, and sprints
• Enterprise system? Add security reviews, compliance checks, and DevOps planning

Domain Awareness

A dating app has different requirements than a medical diagnostic system. BMAD understands this and adjusts:

• What planning documents you need
• How detailed your architecture should be
• What compliance considerations matter
• How to break down work appropriately

Meet Your AI Team: 12+ Specialized Agents

BMAD comes with a full complement of domain experts:

Each agent has:

• Specialized expertise in their domain
• Consistent personality across sessions
• Awareness of other agents’ work
• Guided workflows they can execute

Two Paths: Quick Flow vs Full Planning

Quick Flow (3 Commands)

For bug fixes, small features, or clear-scope work:

# 1. Analyze codebase and create tech-spec with stories
/quick-spec

# 2. Implement each story
/dev-story

# 3. Validate quality
/code-review

When to use Quick Flow:

• Scope is clear (1-15 stories)
• No architectural decisions needed
• Single developer work
• Bug fixes and enhancements

Full Planning Path (BMad Method)

For products, platforms, and complex features:

# Phase 1: Analysis (Optional)
/bmad-brainstorming      # Ideation
/bmad-bmm-research       # Market/technical research
/create-product-brief    # Foundation document

# Phase 2: Planning (Required)
/create-prd              # Full requirements document

# Phase 3: Solutioning
/create-architecture     # Technical design
/create-epics-and-stories # Break into work items
/check-implementation-readiness # Validation

# Phase 4: Implementation
/sprint-planning         # Initialize sprint
/create-story → /dev-story → /code-review  # Per story

When to use Full Planning:

• New products or major features
• Architectural decisions required
• Team collaboration
• 10-50+ stories

Getting Started in 5 Minutes

Prerequisites

• Node.js v20+
• An AI IDE (Claude Code, Cursor, Windsurf, etc.)

Installation

# Install BMAD to your project
npx bmad-method install

# Follow the prompts to select:
# - Modules (BMad Method, BMad Builder, etc.)
# - Your AI IDE
# - Configuration options

Your First Workflow

After installation, open your AI IDE in the project folder:

# Not sure what to do? Ask for help!
/bmad-help

# Or ask specific questions:
/bmad-help How should I build a web app for my T-Shirt business?
/bmad-help I just finished the architecture, what's next?

Real-World Example: Building a Todo API

Let’s walk through building a simple REST API using Quick Flow:

Step 1: Quick Spec

You: /quick-spec

BMAD: I'll analyze your project and create a tech specification.
      What are you trying to build?

You: A REST API for todo items with CRUD operations, user auth,
     and PostgreSQL storage.

BMAD: [Analyzes project structure, existing code, tech stack]
      [Generates tech-spec.md with 6 stories]

      Created: _bmad-output/tech-spec.md
      Stories:
      1. Database schema and migrations
      2. User authentication endpoints
      3. Todo CRUD endpoints
      4. Input validation
      5. Error handling middleware
      6. API documentation

Step 2: Implement Stories

You: /dev-story 1

BMAD: [Reads tech-spec, understands story #1]
      [Implements database schema]
      [Creates migration files]
      [Updates story status to completed]

You: /dev-story 2

BMAD: [Reads existing code, understands auth requirements]
      [Implements JWT-based authentication]
      [Creates user model, auth routes, middleware]

Step 3: Code Review

You: /code-review

BMAD: [Reviews all implemented code]
      [Checks for security issues, best practices]
      [Validates against tech-spec requirements]

      ✅ All stories implemented correctly
      ⚠️ Minor: Consider adding rate limiting to auth endpoints
      ⚠️ Minor: Add index on todos.user_id for performance

Why BMAD Works

1. Structure Without Rigidity

BMAD provides guardrails without being prescriptive. You can:

• Skip optional phases when they don’t add value
• Load agents directly for specific tasks
• Run workflows in any order once you’ve learned the flow

2. Context Persistence

Unlike chat-based AI tools, BMAD:

• Saves all planning documents to files
• Agents read previous outputs automatically
• Your architecture informs your stories
• Your stories guide your implementation

3. Party Mode: Multi-Agent Collaboration

Need multiple perspectives? Party Mode brings agents together:

You: /party-mode PM, Architect, Security

PM: From a product perspective, we need to consider...
Architect: The technical implications of that are...
Security: Before we proceed, let's address these concerns...

4. 100% Free and Open Source

No paywalls. No gated content. No premium Discord channels. BMAD believes in empowering everyone, not just those who can pay.

The Module Ecosystem

BMAD extends through modules:

Coming Up in This Series

Part 2: Workflows Deep Dive — The 4 development phases, practical walkthroughs, and Party Mode in action.

Part 3: BMad Builder — Creating custom agents for your domain.

Part 4: Creative Intelligence Suite — Innovation workflows and design thinking.

Get Started Today

npx bmad-method install

Join the community:

• 🎮 Discord
• 📺 YouTube
• 💻 GitHub

BMAD-Method represents a fundamental shift in how we work with AI for software development. Instead of AI as a tool that replaces thinking, we get AI as a collaborator that enhances it.

Have questions? Drop them in the comments below!

It’s been a while since I’ve posted to dev.to. I just wanted to let you know if you like my writing I do a weekly newsletter called Practical Betterments.

It’s about one-off actions to improve your life continuously — however marginally.

Currently I’m doing a series on creating a dedicated space to help you with goals that require sustained focus.

You can read the first one here:

Create a dedicated focus nook

Here’s some other tips related to productivity and focus:

Add spaces to the dock on MacOS

Block browser notification requests

Place healthy apps within thumbs reach

Let me know what you think!

Ask most business leaders what cybersecurity compliance means to their organization and the answer will center on obligation: avoiding regulatory fines, passing audits, satisfying contractual requirements from enterprise customers. These are real and valid reasons to maintain compliance — but they capture only a fraction of the business value that a mature compliance program actually delivers.
The organizations that treat compliance purely as a legal necessity are leaving significant strategic value on the table. The ones that treat it as a business asset are doing something fundamentally different — and reaping correspondingly different rewards.
The Compliance Landscape Has Changed
Regulatory requirements around data security have expanded dramatically over the last decade, and the trajectory is continuing. Beyond the well-established frameworks — PCI-DSS, HIPAA, ISO 27001, SOC 2, NIST — newer regional and sector-specific requirements are creating additional compliance obligations for businesses operating globally.
The cost of non-compliance has risen alongside the complexity. HIPAA settlements now routinely reach into the tens of millions. GDPR fines of 4% of global annual revenue are not theoretical — they’ve been levied against major organizations. PCI-DSS non-compliance creates liability exposure that payment processors take seriously.
But the more interesting development isn’t the growing stick. It’s the growing carrot.
Compliance as a Business Development Tool
Enterprise procurement has changed. Large organizations and government agencies increasingly require vendors, suppliers, and technology partners to demonstrate security certifications and compliance postures as a condition of doing business. A supplier without ISO 27001 certification or a SOC 2 report may simply not qualify for the RFP.
This dynamic has made security compliance a business development asset in concrete, revenue-linked ways. The organization that can present an ISO 27001 certification, a current SOC 2 Type II report, and documented compliance with relevant industry frameworks wins procurement evaluations that competitors without those credentials lose.
For businesses targeting enterprise customers, regulated industries, or government contracts, a mature compliance program is not overhead — it’s qualification criteria.
The Customer Trust Dimension
Beyond formal procurement requirements, customers increasingly make purchasing decisions based on trust signals around data security. High-profile breaches have made the general business audience acutely aware of the risks associated with sharing sensitive data with vendors. In a competitive market, visible security credentials differentiate.
This is particularly true in industries that handle sensitive personal data: healthcare, financial services, professional services, HR technology, and any SaaS platform that touches customer data. The ability to point to continuous compliance monitoring, third-party certifications, and a documented security program answers the question customers are increasingly asking before they sign.
The Operational Efficiency Angle
Here’s the dimension of compliance value that gets the least attention in business conversations: compliance programs, when implemented well, make organizations more operationally efficient.
The controls required by major security frameworks — access management, system monitoring, change management, incident response procedures, vendor risk management — are not just regulatory checkboxes. They’re foundational security practices that reduce operational risk, improve system reliability, and create documented processes where informal ad-hoc practices previously existed.
Organizations that have matured their compliance programs consistently report secondary benefits: fewer security incidents (the controls work), faster incident response (documented procedures exist and people know them), lower insurance premiums (demonstrable risk management), and reduced audit costs (continuous monitoring replaces last-minute scramble).
The challenge has historically been that compliance programs are expensive to run. Evidence collection, control testing, documentation maintenance, and audit preparation can consume significant internal resources — particularly in organizations managing compliance across multiple frameworks simultaneously.
How Automation Changes the Economics
The emergence of mature GRC (Governance, Risk, and Compliance) automation platforms has substantially changed the economics of running a compliance program. Rather than manually collecting evidence, testing controls, and preparing documentation at audit time, automated platforms provide:
Continuous control monitoring — real-time visibility into whether security controls are operating as designed, not just a point-in-time assessment at audit time.
Automated evidence collection — logs, access records, configuration states, and security events are automatically mapped to specific control requirements and retained in a format audit-ready for review.
Multi-framework management — organizations managing simultaneous compliance with ISO 27001, PCI-DSS, and HIPAA can view their compliance posture across all three frameworks from a single dashboard, with control overlap mapped automatically (many controls satisfy multiple frameworks simultaneously).
Gap identification and remediation guidance — when a control falls out of compliance, the platform identifies it immediately and provides remediation guidance rather than leaving the team to discover it at the next audit.
The operational impact is significant. Organizations using automated GRC platforms consistently report compliance audit preparation time reduced by 60–70% compared to manual approaches. That’s not just efficiency — it’s a meaningful reduction in the risk of compliance failure that comes from compressed, high-pressure manual audit preparation.
Platforms like CyberSilo provide a useful example of how integrated compliance automation works alongside security monitoring — where the same platform that detects threats also continuously tracks compliance posture, eliminating the traditional gap between security operations and compliance management.
Building the Business Case Internally
For business leaders making the case for compliance investment to stakeholders or boards, the conversation benefits from moving beyond the “avoiding fines” frame:
Risk quantification: What is the probability-adjusted annual cost of a major compliance failure (fines, litigation, remediation, reputational damage)? Compliance investment is insurance with a calculable actuarial value.
Revenue impact: What business have you lost or not pursued because of compliance gaps? What contracts would a certification open? These are real revenue numbers.
Operational savings: Estimate the current internal cost of manual compliance operations — audit preparation time, evidence collection, control testing. Compare against automated platform costs.
Competitive positioning: Where does your compliance posture compare to competitors in your market? In regulated verticals, this is often a decisive purchasing criterion.
Presented with these four dimensions quantified, compliance investment typically looks very different from a pure cost center.
The Strategic Conclusion
The businesses that will perform best in the next five years of an increasingly regulated, increasingly scrutinized digital economy are those that have built compliance into their operations as a continuous, automated function — not those scrambling to prepare documentation every time an audit looms.
Compliance is a lagging indicator of security maturity. Organizations with genuinely strong security programs find compliance straightforward — because the controls are already in place, the evidence is already being generated, and the documentation already exists. The compliance program becomes a certification of what the organization is already doing.
Framed that way, the investment case for compliance automation isn’t really about compliance at all. It’s about building a security program that’s genuinely effective — and then letting the compliance certifications and competitive advantages follow naturally.

If you’ve ever had a printed contract, a handwritten note, or a physical receipt that you desperately needed as a PDF — and found yourself wrestling with apps that either upload your files to some random server, slap a watermark on the result, or charge you after three free scans — you know the frustration.
There’s a better way. It’s called ihatepdf.cv, and it runs entirely in your browser.

What ihatepdf.cv Actually Does
ihatepdf.cv is a free browser-based document scanner. You open it, point your phone or laptop camera at a piece of paper, and it spits out a clean, flat, searchable PDF — with no account required, no file ever leaving your device, and absolutely no watermark.
It’s the kind of tool that should have always existed. Here’s what happens under the hood when you hit that shutter button.

Step 1: It Detects the Document Edges Automatically
The moment you capture a frame, ihatepdf.cv runs an edge-detection algorithm directly in JavaScript — no computer vision library, no WebAssembly blob to download. It applies a Gaussian blur to reduce noise, then runs a Sobel operator across the image to find where brightness changes sharply (i.e., where your document meets the desk or background).
The four corners of your document are estimated from those edge points and shown as draggable handles on screen. Most of the time the auto-detect is spot on. When it isn’t, you just drag the corners yourself — and a little magnifying loupe pops up under your finger so you can place them with pixel-level precision.

Step 2: Perspective Correction (The Magic Part)
This is what separates a real document scanner from just “taking a photo.” Even if your paper is at an angle — tilted 20 degrees, shot from the side — ihatepdf.cv mathematically flattens it.
It computes a homography matrix: a transformation that maps your four selected corners to a perfect rectangle. Then it walks every pixel of the output image backwards through that transformation to find where it came from in the original photo. The result is a flat, de-skewed document that looks like it came off a flatbed scanner.
No OpenCV. No server. Eight equations, eight unknowns, solved in JavaScript.

Step 3: Enhancement — Make It Actually Readable
Raw camera images are often too soft or too grey for OCR to work well. ihatepdf.cv gives you five one-tap presets:

Original — untouched, exactly what the camera saw
Document — boosted contrast and brightness, great for printed text
B&W — full greyscale with heavy contrast, sharp black text on white
Whiteboard — aggressive brightness lift for whiteboard photos
Photo — gentle enhancement for mixed-content pages

You can also fine-tune brightness and contrast manually with sliders. Any preset can be applied to all pages in one tap — useful when you’re scanning a multi-page document in the same lighting conditions.

Step 4: OCR — Turn Your Scan Into a Searchable PDF
This is the feature that makes the output genuinely useful rather than just a pretty image. After you’ve captured and adjusted your pages, hitting “Scan & Extract Text” fires up Tesseract.js — an open-source OCR engine that runs locally in your browser.
It supports 17 languages including English, Hindi, French, German, Arabic, Chinese, Japanese, Korean, and more. Set it to Auto and it detects the script automatically from your first page.
Before OCR runs, ihatepdf.cv preprocesses each image:

Normalises the contrast range so faint text becomes visible
Sharpens edges with a Laplacian filter
Upscales small images to the sweet spot for Tesseract accuracy (~1800px)
If confidence is low, automatically retries on a binarised (black and white) version

The extracted words, along with their exact positions on the page, are embedded as an invisible text layer in the final PDF — white text sitting just underneath the image. The document looks exactly like your scan, but you can select text, search with Ctrl+F, and have it indexed by any search engine or document manager.

Step 5: Export Options That Don’t Hold You Hostage
Once processed, you get:

Download as PDF — a proper searchable PDF, no watermark, no size limit other than your device’s memory
Download as .txt — the raw extracted text, useful for pasting into other documents
Copy text — one tap to clipboard
Share — on mobile, triggers the native share sheet so you can AirDrop, send via WhatsApp, email it, whatever

There’s also a merge feature: if you already have an existing PDF, you can load it and choose whether your new scan goes before or after it. Useful when you’re adding pages to a report or combining a handwritten note with a typed document.

Multi-Page and Batch Scanning
Single-page scanning is the easy case. ihatepdf.cv handles multi-page documents too.
After each capture, you land back in a review screen where your pages appear as a scrollable thumbnail strip. Tap any thumbnail to preview it full-screen. Drag thumbnails to reorder pages. Long-press for a context menu that lets you rotate, replace, move, or delete individual pages. Swipe left and right on the preview to navigate between pages.
For situations where you need to quickly capture a stack of documents, Batch mode lets you keep the camera open and shoot as many frames as you want. You then review all captures at once, edit corners on any that need it, and add everything to your document in a single step.
A small coloured dot on each thumbnail gives you a blur quality score — green means sharp, amber is borderline, red means you should retake it. It’s a small thing, but it saves you from building a 20-page PDF only to find page 7 is unreadable.

Why “No Upload” Actually Matters
Most online PDF tools — even the free ones — route your files through a server. That’s fine for a grocery receipt. It’s less fine for:

Medical records
Legal contracts
Financial statements
ID documents
Confidential work files

ihatepdf.cv processes everything on your device. The image never leaves. There’s no server log of what you scanned, no storage bucket somewhere holding your documents, no terms of service clause about training AI on your uploads.
This isn’t a privacy marketing line. It’s just what happens when you do image processing in JavaScript on a canvas element. The data literally cannot go anywhere because there’s nowhere to send it.

Works Without an Internet Connection
Once the page loads, ihatepdf.cv works offline. The OCR language models are fetched on first use and cached by the browser. After that, you could put your phone in airplane mode and scan a full document to a searchable PDF without any network activity.
This matters more than it sounds. You’re scanning in a basement. On a plane. In a client meeting where pulling out your phone to use some cloud service looks unprofessional. ihatepdf.cv doesn’t care.

Import From Your Gallery Too
Don’t have something in front of you to scan right now? You can import existing photos from your camera roll. ihatepdf.cv runs the same edge detection and perspective correction on imported images, automatically applies the Document filter, and adds them to your page stack just like a live capture.
This is useful for: photos you already took of a whiteboard, photos of receipts sent to you by someone else, or images of documents you photographed earlier without a scanning app.

The Short Version
If you need to turn a physical document into a PDF and you want it to be:

Free
Searchable
Watermark-free
Private (nothing uploaded)
Available offline
Multi-language
Multi-page

— ihatepdf.cv does all of that. In your browser. Right now.
No sign-up. No install. Try ihatepdf.cv now →

If you’ve ever had a printed contract, a handwritten note, or a physical receipt that you desperately needed as a PDF — and found yourself wrestling with apps that either upload your files to some random server, slap a watermark on the result, or charge you after three free scans — you know the frustration.
There’s a better way. And it runs entirely in your browser.

What DocScan Actually Does
DocScan is a browser-based document scanner. You open it, point your phone or laptop camera at a piece of paper, and it spits out a clean, flat, searchable PDF — with no account required, no file ever leaving your device, and absolutely no watermark.
It’s the kind of tool that should have always existed. Here’s what happens under the hood when you hit that shutter button.

Step 1: It Detects the Document Edges Automatically
The moment you capture a frame, DocScan runs an edge-detection algorithm directly in JavaScript — no computer vision library, no WebAssembly blob to download. It applies a Gaussian blur to reduce noise, then runs a Sobel operator across the image to find where brightness changes sharply (i.e., where your document meets the desk or background).
The four corners of your document are estimated from those edge points and shown as draggable handles on screen. Most of the time the auto-detect is spot on. When it isn’t, you just drag the corners yourself — and a little magnifying loupe pops up under your finger so you can place them with pixel-level precision.

Step 2: Perspective Correction (The Magic Part)
This is what separates a real document scanner from just “taking a photo.” Even if your paper is at an angle — tilted 20 degrees, shot from the side — DocScan mathematically flattens it.
It computes a homography matrix: a transformation that maps your four selected corners to a perfect rectangle. Then it walks every pixel of the output image backwards through that transformation to find where it came from in the original photo. The result is a flat, de-skewed document that looks like it came off a flatbed scanner.
No OpenCV. No server. Eight equations, eight unknowns, solved in JavaScript.

Step 3: Enhancement — Make It Actually Readable
Raw camera images are often too soft or too grey for OCR to work well. DocScan gives you five one-tap presets:

Original — untouched, exactly what the camera saw
Document — boosted contrast and brightness, great for printed text
B&W — full greyscale with heavy contrast, sharp black text on white
Whiteboard — aggressive brightness lift for whiteboard photos
Photo — gentle enhancement for mixed-content pages

You can also fine-tune brightness and contrast manually with sliders. Any preset can be applied to all pages in one tap — useful when you’re scanning a multi-page document in the same lighting conditions.

Step 4: OCR — Turn Your Scan Into a Searchable PDF
This is the feature that makes the output genuinely useful rather than just a pretty image. After you’ve captured and adjusted your pages, hitting “Scan & Extract Text” fires up Tesseract.js — an open-source OCR engine that runs locally in your browser.
It supports 17 languages including English, Hindi, French, German, Arabic, Chinese, Japanese, Korean, and more. Set it to Auto and it detects the script automatically from your first page.
Before OCR runs, DocScan preprocesses each image:

Normalises the contrast range so faint text becomes visible
Sharpens edges with a Laplacian filter
Upscales small images to the sweet spot for Tesseract accuracy (~1800px)
If confidence is low, automatically retries on a binarised (black and white) version

The extracted words, along with their exact positions on the page, are embedded as an invisible text layer in the final PDF — white text sitting just underneath the image. The document looks exactly like your scan, but you can select text, search with Ctrl+F, and have it indexed by any search engine or document manager.

Step 5: Export Options That Don’t Hold You Hostage
Once processed, you get:

Download as PDF — a proper searchable PDF, no watermark, no size limit other than your device’s memory
Download as .txt — the raw extracted text, useful for pasting into other documents
Copy text — one tap to clipboard
Share — on mobile, triggers the native share sheet so you can AirDrop, send via WhatsApp, email it, whatever

There’s also a merge feature: if you already have an existing PDF, you can load it and choose whether your new scan goes before or after it. Useful when you’re adding pages to a report or combining a handwritten note with a typed document.

Multi-Page and Batch Scanning
Single-page scanning is the easy case. DocScan handles multi-page documents too.
After each capture, you land back in a review screen where your pages appear as a scrollable thumbnail strip. Tap any thumbnail to preview it full-screen. Drag thumbnails to reorder pages. Long-press for a context menu that lets you rotate, replace, move, or delete individual pages. Swipe left and right on the preview to navigate between pages.
For situations where you need to quickly capture a stack of documents, Batch mode lets you keep the camera open and shoot as many frames as you want. You then review all captures at once, edit corners on any that need it, and add everything to your document in a single step.
A small coloured dot on each thumbnail gives you a blur quality score — green means sharp, amber is borderline, red means you should retake it. It’s a small thing, but it saves you from building a 20-page PDF only to find page 7 is unreadable.

Why “No Upload” Actually Matters
Most online PDF tools — even the free ones — route your files through a server. That’s fine for a grocery receipt. It’s less fine for:

Medical records
Legal contracts
Financial statements
ID documents
Confidential work files

DocScan processes everything on your device. The image never leaves. There’s no server log of what you scanned, no storage bucket somewhere holding your documents, no terms of service clause about training AI on your uploads.
This isn’t a privacy marketing line. It’s just what happens when you do image processing in JavaScript on a canvas element. The data literally cannot go anywhere because there’s nowhere to send it.

Works Without an Internet Connection
Once the page loads, DocScan works offline. The OCR language models are fetched on first use and cached by the browser. After that, you could put your phone in airplane mode and scan a full document to a searchable PDF without any network activity.
This matters more than it sounds. You’re scanning in a basement. On a plane. In a client meeting where pulling out your phone to use some cloud service looks unprofessional. DocScan doesn’t care.

Import From Your Gallery Too
Don’t have something in front of you to scan right now? You can import existing photos from your camera roll. DocScan runs the same edge detection and perspective correction on imported images, automatically applies the Document filter, and adds them to your page stack just like a live capture.
This is useful for: photos you already took of a whiteboard, photos of receipts sent to you by someone else, or images of documents you photographed earlier without a scanning app.

The Short Version
If you need to turn a physical document into a PDF and you want it to be:

Free
Searchable
Watermark-free
Private (nothing uploaded)
Available offline
Multi-language
Multi-page

— DocScan does all of that. In your browser. Right now.
No sign-up. No install. Just open it and scan.

I recently shipped a desktop app. No React. No npm. No node_modules. AI generated most of the UI code, and it worked better without a framework than it ever would have with one.

Streaming real-time content, managing complex state, drag-and-drop reordering, resizable layouts — all in plain Web Components and imperative DOM manipulation. Zero runtime dependencies.

This wasn’t an ideological choice. It just turned out that when AI writes your UI, frameworks get in the way more than they help.

Why frameworks existed

Think about what React actually solved when it came out. The browser DOM API was painful. Managing state across components was a mess. Keeping the UI in sync with data required tons of boilerplate. Frameworks abstracted all of that away.

But that was 2013. Since then, two things changed:

The platform caught up. Web Components, custom elements, CustomEvent, CSS custom properties, prefers-color-scheme, ResizeObserver, MutationObserver, template literals. The browser now has native answers to most of the problems that React was invented to solve.

AI writes the boilerplate. The remaining argument for frameworks is developer ergonomics — less repetitive code. But when AI generates your components, that argument disappears. AI doesn’t get bored writing document.createElement. It doesn’t need JSX to be productive. It just writes the code, and the code uses APIs that every model knows because they’ve been in every browser for years.

So you end up with: the platform handles the hard stuff natively, and AI handles the tedious stuff. What’s left for the framework to do?

The setup

The app is an Electron desktop app. The renderer is the part users interact with: a chat panel, tab bar, agent sidebar, task panel, status line. Standard desktop app stuff.

When I started, I figured I’d add React later when things got complex enough. That moment never came.

What the code actually looks like

Every component in the app follows the same pattern. There’s a render() method. When state changes, it gets called. It updates the DOM.

That’s it. That’s the architecture.

The DOM structure gets built once. After that, updates only touch what actually changed. No virtual DOM doing the diffing for me. I know what changed because I’m the one who changed it.

React’s entire selling point is “you describe what the UI should look like and we figure out the minimal DOM updates.” But if you already know what changed… you don’t need someone to figure it out. You just update that thing.

DOM caching without a virtual DOM

The chat component renders message blocks from an AI agent — text, code, tool calls, tool results. Messages stream in real-time. This needs to be fast.

My approach: a WeakMap that tracks what each DOM element was last rendered from. On update, compare the cache entry. If it matches, skip it. Remove elements that no longer exist, append new ones.

This is what React’s reconciler does, except I’m doing it for the one place that actually needs it. The rest of the app doesn’t need diffing at all — the DOM structure is stable, only content changes.

Event delegation over binding

Instead of attaching click handlers to every interactive element, I attach one handler to the container. It checks what was clicked using closest() and acts accordingly. New elements added to the DOM? Already covered. No need to bind or unbind anything.

This is old-school DOM programming. jQuery developers did this in 2010. It still works great.

What AI gets wrong with frameworks

Here’s the thing nobody talks about. Ask AI to build you a component in React and it’ll give you something that looks right. But then you need state management — and it picks a library you don’t use. Or it uses an older API pattern. Or it generates a hook that doesn’t compose well with the rest of your app. You spend time fixing the framework-specific parts, not the actual logic.

Ask AI to do the same thing with plain DOM manipulation and there’s nothing to get wrong. createElement, appendChild, addEventListener — these APIs haven’t changed. There’s no version mismatch, no deprecated patterns, no competing conventions for how to structure things.

The framework was supposed to make development faster. But when AI writes the code, the framework becomes the part that slows you down — it’s the thing that needs to be done correctly according to conventions that the model may or may not know.

Why you don’t need npm either

I needed a markdown parser for rendering LLM responses. Normally you’d npm install something. Instead I asked AI to generate one. It came out to about 300 lines. Handles code blocks, tables, lists, blockquotes, links, images — everything that actually shows up in LLM output.

I needed a state store for sharing data between components. AI generated a small one with selector-based subscriptions. About 50 lines.

I needed CSS theming with light/dark mode. That’s just CSS custom properties and a prefers-color-scheme media query. The browser does this natively now.

Every time I thought “I need a library for this,” I asked AI to write it instead. And every time, the result was a few hundred lines of code that does exactly what I need, nothing more. No transitive dependencies, no breaking changes on update, no 200KB bundle for a feature I use 10% of.

When AI can generate a focused solution in seconds, what’s the point of importing a general-purpose library?

The stability argument

Here’s a bonus you don’t think about until it matters: nothing in my app can break without me changing it.

No dependency will release a version that deprecates an API I use. No framework will ship a migration guide I have to follow. No package in my tree will get a CVE that forces an emergency update on a Friday night.

When your code only depends on browser APIs, the only thing that can break it is the browser. And browsers don’t break backwards compatibility. A Web Component I write today will work in 2030. Can you say that about your React 19 code?

When this doesn’t apply

I’m not going to pretend this works for everything. If you have a team of 20 people and everyone knows React, use React. The shared conventions are worth more than the technical purity.

But if you’re building something yourself, or with AI doing most of the generation — consider whether the framework is helping you or just giving AI more ways to make mistakes.

The platform handles the hard stuff natively. AI handles the tedious stuff. Frameworks used to sit in between. I’m not sure they need to anymore.

AgentWFY is open source, MIT licensed. The renderer code is in src/renderer/ if you want to see how all of this looks in practice.

The AI Tidal Wave: Are You Building Boats or Waiting for the Tsunami?

Another week, another flood of “Will AI Replace Developers?” articles. While that existential debate rages, a quiet revolution is already underway in the trenches. The real question isn’t about replacement; it’s about augmentation. How can you, as a developer, harness AI tools today to write better code, solve complex problems faster, and free up your mental bandwidth for truly creative engineering?

This guide moves past the hype. We’ll explore practical, actionable strategies for integrating AI into your daily development workflow, complete with code examples and real-world use cases. Let’s stop speculating about the future and start building it.

The AI Toolbox: More Than Just a Chatbot

Before we dive into workflows, let’s categorize the AI tools at your disposal. Think of this as your new developer toolkit.

1. Code-Autocomplete & Generation (e.g., GitHub Copilot, Tabnine): Your intelligent pair programmer, suggesting whole lines, functions, and blocks of code based on context.
2. Chat-Driven Development (e.g., ChatGPT, Claude, specialized coding assistants): A conversational partner for explaining concepts, generating code from descriptions, debugging, and refactoring.
3. AI-Powered Code Review & Analysis (e.g., SonarCloud with AI, Amazon CodeWhisperer security scans): Proactive tools that identify bugs, security vulnerabilities, and suggest optimizations beyond static analysis.
4. AI for DevOps & Operations (e.g., AI-powered log analyzers, predictive monitoring): Tools that parse mountains of operational data to find anomalies, predict failures, and suggest fixes.

Integrating AI into Your Development Loop: A Phase-by-Phase Guide

Phase 1: Planning & Design

Instead of staring at a blank README.md, use a chat-based AI to kickstart your design process.

Prompt Example:

“Act as a senior software architect. I need to design a RESTful API for a task management application. It should have users, projects, and tasks. Generate a concise design document outlining the core models, key endpoints (with HTTP methods), and a suggested database schema in SQL.”

This gives you a structured first draft to critique, refine, and build upon. It’s a brainstorming partner that never gets tired.

Phase 2: Implementation (Where the Magic Happens)

This is where tools like GitHub Copilot shine. The key is context. Write descriptive function names, comments, and docstrings to guide the AI.

Bad Context:

function processData(data) {
  // code here
}

Good Context:

/**
 * Calculates the moving average of an array of numerical data.
 * @param {number[]} data - The input array of numbers.
 * @param {number} windowSize - The size of the moving window.
 * @returns {number[]} An array of moving averages. Handles edges by using a partial window.
 */
function calculateMovingAverage(data, windowSize) {
  // Copilot now has excellent context to generate accurate code.
}

When you hit a known but tedious pattern—like creating a React component with PropTypes, or a standard Express.js controller—let the AI generate the boilerplate. Then, you focus on the unique business logic.

Phase 3: Debugging & Problem Solving

Hit a cryptic error? Paste the error message and the relevant 10-15 lines of code into your chat assistant.

Prompt Example:

“I’m getting this error in my Python Flask app: sqlalchemy.exc.IntegrityError: (sqlite3.IntegrityError) NOT NULL constraint failed: post.user_id. Here’s my model definition and the save function: [paste code]. What’s the most likely cause and how do I fix it?”

The AI can quickly explain the foreign key constraint issue and suggest checking if the user object is properly associated before committing. It’s like having a senior developer on call 24/7 for those “stuck” moments.

Phase 4: Code Review & Refactoring

Use AI to critique your own code before the human review.

Prompt Example:

“Review this JavaScript function for potential issues, performance improvements, and readability. Suggest a refactored version.”

function getActiveUsers(users) {
  let active = [];
  for (let i = 0; i < users.length; i++) {
    if (users[i].isActive && users[i].lastLogin > Date.now() - 86400000) {
      active.push(users[i]);
    }
  }
  return active;
}

Potential AI Response:

“Consider using filter() for clarity and immutability. The magic number 86400000 should be a named constant. Also, consider extracting the condition into a well-named helper function for readability.”

const ONE_DAY_MS = 24 * 60 * 60 * 1000;
const isUserActive = (user) => user.isActive && user.lastLogin > Date.now() - ONE_DAY_MS;

function getActiveUsers(users) {
  return users.filter(isUserActive);
}

Advanced Tactics: Prompt Engineering for Developers

To get the best results, you need to speak the AI’s language. Here are key techniques:

• Be Specific & Provide Context: “Write a Python function to parse this specific log format” is better than “write a parser.”
• Ask for Step-by-Step Reasoning: For complex problems, prompt: “Let’s think step by step. How would I implement a rate-limiting middleware in Node.js?”
• Iterate and Refine: Treat the first output as a draft. Follow up with: “That’s good, but now make it asynchronous and add error handling for network timeouts.”

• Provide Examples (Few-Shot Learning): Show the AI the pattern you want.

  // Convert these strings to title case:
  // Input: "hello_world_example" -> Output: "Hello World Example"
  // Input: "userID" -> Output: "User ID"
  // Now, convert: "api_response_data"
  

The Human in the Loop: Critical Responsibilities AI Can’t Handle

AI is a powerful lever, but you are the architect. Your irreplaceable responsibilities include:

• Architectural Vision: Understanding the broader system, trade-offs, and long-term maintainability.
• Business Logic & Domain Expertise: Translating nuanced business rules into technical requirements.
• Final Judgment & Ethics: Evaluating AI suggestions for security flaws, bias, or inappropriate solutions.
• Craftsmanship & User Experience: Ensuring the final product is elegant, usable, and brings joy.
• Asking the Right Questions: AI answers what you ask. Defining the problem is still a profoundly human skill.

Getting Started: Your Action Plan

1. Pick One Tool: Start small. Install GitHub Copilot or get proficient with the coding mode of ChatGPT/Claude.
2. Integrate into One Task: Use it for writing unit tests, which are often repetitive and well-defined. Prompt: “Write 3 Jest test cases for this React component: [paste component].”
3. Practice Prompting: Spend 15 minutes a day solving small coding puzzles with an AI assistant. Notice what prompts give the best results.
4. Critically Evaluate Every Suggestion: Never accept code blindly. Understand why the AI wrote what it did.

The developers who thrive in this new era won’t be the ones who fear AI, but the ones who learn to direct it with skill and judgment. The tool is here. The question is, how will you use it to build what’s next?

Start today. Pick one small problem from your current backlog and solve it with an AI assistant. Share what you learn. The future of development isn’t about being replaced—it’s about being amplified.