DEV Community: Nauman Ahmad

What on Earth is "Agentic Browsing"?

Nauman Ahmad — Wed, 17 Jun 2026 12:51:03 +0000

I Built a Vanilla JS Web App that Scored 100/100 Under Lighthouse’s New "Agentic Browsing" Audit. Here’s What It Means.

If you have run a performance audit on PageSpeed Insights or Lighthouse recently, you might have noticed a fascinating new line item quietly slipping into the metadata report: Agentic Browsing.

When I audited my free tool suite, Paktheta, I managed to hit the ultimate developer milestone—a perfect 100/100 across Performance, Accessibility, Best Practices, and SEO. But seeing that perfect score alongside the label "Agentic Browsing" got me thinking. What exactly is an AI-driven agent experiencing when it hits our sites, and why is this the new gold standard for web performance?

Let's dive into what Agentic Browsing actually means for the future of optimization.

What on Earth is "Agentic Browsing"?

Historically, speed tests like Lighthouse were passive. A headless browser opened your URL, waited for the page to load, recorded metrics like First Contentful Paint (FCP) and Largest Contentful Paint (LCP), and closed the tab. It was a linear, predictable, and frankly synthetic snapshot.

Agentic Browsing changes the paradigm entirely. Instead of a basic static script, modern auditing platforms use autonomous, intelligent browser agents. Guided by modern AI-driven browser control (using updated instances like HeadlessChromium), these agents don't just stare at your page—they explore it like a real human would.

An agentic audit runner will:

Identify interactive buttons and click them to test responsiveness.
Scan form elements to see if they accept paste commands cleanly.
Intelligently look for broken layout shifts (CLS) by dynamically scrolling and triggering micro-animations.
Interact with JavaScript components to see if they block the main execution thread.

In short: It simulates real, unpredictable human behavior at lightning speed. If your site relies on bloated frameworks that look fast initially but lock up the second a user tries to interact, an agentic browser will catch it instantly and tank your Interaction to Next Paint (INP) or Total Blocking Time (TBT).

Deconstructing the Quad-100: How We Handled the Agent

When the agent ran through the Paktheta JPG to PDF Tool, it simulated a real mobile session (emulating a Moto G Power on a throttled 4G network).

Here is how the numbers shook down, and why pure optimization still triumphs over heavy modern frameworks:

1. Zero Main-Thread Jank (Performance: 100)

The agent recorded a Total Blocking Time (TBT) of exactly 0 ms.

The Secret: Avoid heavy JavaScript frameworks for simple utility pages. By using vanilla execution architecture and optimizing DOM depth (keeping total elements down to a lean 112), the browser spent a mere 16 milliseconds evaluating scripts. There was zero framework hydration lag to slow down the agent's interactive clicks.

2. Predictable, Static Layouts (CLS: 0)

The agent searched aggressively for layout shifts during its browsing loop. The result? A Cumulative Layout Shift (CLS) of 0.

The Secret: Every button and container size is strictly calculated. Even under CSS pulse-glow animations on interactive buttons, the core layout boundaries remain rigid, ensuring the content never jumps unexpectedly while an autonomous agent or human eye is trying to read it.

3. Immediate Time-To-First-Byte (TTFB)

The initial network request latency clocking in at an elite 10 ms.

The Secret: Smart caching structures and an incredibly light payload (totaling only 28 KiB for the entire page transfer).

The Takeaway: Stop Building for Static Bots; Build for Active Agents

The introduction of Agentic Browsing to standard web testing utilities means that trying to "game" the system with superficial tricks won't cut it anymore. Algorithms are smart enough to look for actual functional flow.

If you want to achieve perfect scores in this new era:

Keep it lightweight: If vanilla JS can solve the problem, let it.
Ensure interactive components are resilient: If an AI agent can't focus your keyboard elements, click a button smoothly, or navigate your DOM, it will penalize your accessibility and best practices scores.
Optimize for interaction, not just the initial paint: It’s no longer just about how fast your page renders; it's about how gracefully it behaves when it is pushed to perform.

Have you noticed the new agentic metrics appearing on your latest builds? Let me know in the comments how you’re optimizing your workflows to handle them!

How I Built a 100% Offline, Privacy-First Image to PDF Converter Using AI

Nauman Ahmad — Fri, 29 May 2026 04:33:02 +0000

Every single day, millions of people search for a quick way to convert images into PDF documents. Whether it's a student submitting an assignment, a lawyer processing legal files, or a freelancer sending an invoice, the need is massive.

But as developers and tech enthusiasts, we know the dark side of most "free" online tools:

Data Security Risks: They upload sensitive user documents (IDs, bank statements, passports) to remote cloud servers.
Paywalls & Watermarks: They hit users with sudden limitations, forcing upgrades to premium versions.
Tracking & Cookies: They track user data across the web for ad targeting.

I wanted to change that. I wanted to build a tool that gives power back to the user—a utility that is 100% free, blisteringly fast, and completely secure.

So, with the help of modern AI coding assistants, I built and launched the PakTheta JPG to PDF Converter. Here is how I designed a client-side architecture that runs entirely in the user's browser window!

🛠️ The Architecture: 100% Client-Side (No Servers Allowed)

The absolute core of this project was data privacy. To guarantee that user documents remain secure, I decided that user files must never touch a server.

By leveraging AI to brainstorm the best browser-side rendering libraries and vanilla JavaScript structures, we engineered a completely serverless workflow. When a user visits paktheta.com/pdf/jpg-to-pdf, the application logic loads once. After that, they can literally turn off their internet connection, and the conversion still works flawlessly!

📦 Handling the Multi-Format Nightmare

One of the trickiest parts of client-side image processing is format compatibility. Standard HTML canvases struggle with raw image wrappers. AI helped me write robust parsing loops to support a massive matrix of extensions instantly:

Legacy & Web Formats: JPG, JPEG, PNG, BMP, GIF, WebP.
Vector & Design Files: SVG, TIFF.
Modern Mobile Formats: High-efficiency wrappers like HEIC (iPhone photos) and AVIF.

The AI assistance was crucial in debugging binary buffer streams, ensuring that regardless of the file type uploaded, the browser decodes it smoothly without dropping pixel density or crashing the tab.

🌟 Premium Features We Added (With Zero Bloat)

Thanks to rapid prototyping with AI, I didn't stop at a basic converter. We packed heavy customization options directly into the local browser UI, matching premium enterprise software features:

📐 Complete Layout Control: Users can set page sizes to standard A4, Letter, Legal, or match the exact "Original Image Size" dynamically.
📏 Precision Margins: Adjustable Top, Bottom, Left, and Right margins measured precisely in millimeters (mm).
📝 Rich Typography Canvas: Users can stamp rich text headings and descriptions directly onto the PDF file with custom font sizes, alignments, and styles (Bold, Italic, Underline).
🔢 Dynamic Pagination: Automatic layout calculations to place page numbers (e.g., Page 1 of {total}) in multiple grid structures.
🗜️ Local Compression Engine: To prevent massive file weights, we added a client-side compression slider (No Compression, Medium, High) that scales down image quality locally before compiling the PDF binary tree.
🗂️ Bulk Download Options: Users can either compile everything into a single, clean PDF file or download separate PDFs bundled inside a single .zip file automatically.

🤖 The AI Collaboration Experience

Building this alone would have taken weeks of diving into PDF binary specifications, array buffers, and stream-saving APIs. By collaborating with AI, the development cycle was cut down significantly:

Memory Optimization: AI helped me optimize the JavaScript garbage collection so that converting 50+ high-res images at once doesn't trigger an out-of-memory error on mobile browser tabs.
UI/UX Refinement: We generated a clean, responsive layout that scales beautifully from a 4K desktop display down to a small mobile screen.
Zero Watermarks: AI helped me ensure the compilation script outputs pure, unblemished PDF trees, making it instantly ready for professional and corporate use.

🎯 Try It Out & Give Feedback!

This project taught me that when you combine a utility need with a privacy-first mindset and AI acceleration, you can build tools that truly rival paid software while respecting the user's digital rights.

I would love for the Dev.to community to test the live utility, inspect the network tab (to verify zero data transmission!), and leave your valuable feedback in the comments.

🔗 Live Tool: https://paktheta.com/pdf/jpg-to-pdf

How do you handle client-side PDF generation in your projects? Let's discuss in the comments below!