DEV Community: cadguide.tools

Generative Engine Optimization (GEO) 101: A Developer's Technical Checklist

cadguide.tools — Mon, 17 Aug 2026 09:08:48 +0000

Search is undergoing its biggest transformation in 25 years. As developers, we are transitioning from standard Search Engine Optimization (SEO) to Generative Engine Optimization (GEO).

While traditional SEO focused on keywords, backlinks, and meta tags, GEO focuses on semantic readability, machine-readable structured data, citation clarity, and LLM context endpoints.

Here is a practical technical checklist to get your web app AI-ready.

📋 The Technical GEO Checklist

1. Structure Machine-Readable Metadata (JSON-LD)

LLMs extract factual entity relationships from structured data. Standard OpenGraph tags are good for social previews, but rich JSON-LD is essential for AI knowledge graphs:

Implement FAQPage Schema for question-and-answer sections.
Implement TechArticle or Article Schema with author, dates, and clear descriptions.
Implement SoftwareApplication Schema for SaaS and developer tools.

👉 Generate schemas for free: GEOKit Schema Generator

2. Implement `llms.txt` at the Root

Provide clean Markdown documentation for AI parsers at /llms.txt.

Keep summaries under 150 words.
Link to direct .md mirrors of documentation or main landing pages.

👉 Visual builder: GEOKit llms.txt Builder

3. Clear AI Crawler Permissions in `robots.txt`

Ensure OAI-SearchBot, PerplexityBot, and ClaudeBot are explicitly allowed so they can cite your content when users ask questions.

👉 Configuration tool: GEOKit AI Robots.txt Builder

4. Semantic HTML & Clear Heading Hierarchy

Generative engines chunk web pages by semantic headers (<h1>, <h2>, <h3>).

Avoid using generic <div> tags for headings.
Ensure questions are explicit in <h2> tags (e.g., How does X work? followed by a direct 2-3 sentence answer).

5. Audit Your AI Readiness Score

Run automated audits against your web app to check headings, markdown digestibility, and crawler accessibility.

👉 Free live test: GEOKit AI Readiness Checker

🛠️ Explore the Full GEO Toolkit

All 20+ Generative Engine Optimization tools mentioned above are 100% free, privacy-friendly, and open for developers at GEOKit.site.

What GEO techniques are you currently testing in your projects? Let's discuss in the comments!

How to Configure AI Robots.txt in 2026: Search Citations vs Training Scrapers

cadguide.tools — Mon, 17 Aug 2026 09:08:07 +0000

With the rise of generative search, webmasters face a crucial dilemma:

On one hand: You want real-time AI search engines (like Perplexity, ChatGPT Search, and Claude) to crawl your pages and provide direct citations and backlink referrals to your product.
On the other hand: You may want to restrict aggressive background data scrapers from consuming server bandwidth or training foundation models without attribution.

In 2026, standard robots.txt files with simple User-agent: * rules are no longer sufficient. Here is how to configure granular crawler access for modern AI bots.

🤖 Understanding the Major AI Crawlers

Not all AI bots serve the same purpose. Here is the distinction between search crawlers and training scrapers:

Crawler	User-Agent	Primary Purpose	Best Practice
ChatGPT Search	`OAI-SearchBot`	Real-time search queries in ChatGPT	Allow
Perplexity	`PerplexityBot`	Real-time source retrieval & citations	Allow
Claude Search	`ClaudeBot`	Anthropic Claude real-time web citations	Allow
Apple Intelligence	`Applebot-Extended`	Apple AI web search indexing	Allow
OpenAI Training	`GPTBot`	Foundation model training data	Configurable
ByteDance Scraper	`Bytespider`	Aggressive TikTok/ByteDance scraper	Block/Rate-Limit

📄 Recommended `robots.txt` Configuration Template

Here is a battle-tested template that allows high-value AI search crawlers while protecting your sensitive routes and blocking heavy scrapers:

# Standard Search Engines
User-agent: Googlebot
User-agent: Bingbot
Allow: /

# Generative Search Bots (Enable AI Citations)
User-agent: OAI-SearchBot
User-agent: PerplexityBot
User-agent: ClaudeBot
User-agent: Applebot-Extended
Allow: /
Allow: /llms.txt
Allow: /docs/
Disallow: /api/
Disallow: /admin/

# Restrict Aggressive Unlicensed Scrapers
User-agent: Bytespider
User-agent: CCBot
Disallow: /

# Sitemap Location
Sitemap: https://yourdomain.com/sitemap.xml

🛠️ Free Developer Tools for Testing & Generation

Instead of writing complex syntax by hand and risking unintended crawler lockouts, you can use these free utilities:

🤖 AI Robots.txt Generator: Interactive UI to toggle permissions for 15+ AI crawlers with one click.
🔍 AI Crawler Tester: Test whether specific AI bots (like PerplexityBot or GPTBot) are currently permitted or blocked on your live URLs.
📋 AI Crawlers Directory: Up-to-date registry of verified AI user-agents and IP ranges.

All of these tools are free and run client-side on GEOKit.

💡 Summary

Fine-tuning your robots.txt ensures your website remains discoverable in the AI search era without sacrificing your server resources. Take 5 minutes to audit your site today!

The Complete Guide to llms.txt: How to Prepare Your Web App for AI Search Engines

cadguide.tools — Mon, 17 Aug 2026 09:08:06 +0000

Over the past two years, the way people discover information on the web has fundamentally shifted. Traditional Google "10 blue links" are increasingly supplemented or replaced by generative answers from ChatGPT Search, Perplexity, Claude, and Google AI Overviews.

To help AI systems parse and cite web documentation without wasting tokens on navigation menus, ads, and boilerplate HTML, the open web community proposed a new standard: llms.txt.

In this guide, we'll cover what llms.txt is, how it works, and how you can implement it in your web app today using free, client-side tools.

🤖 What is `llms.txt`?

Think of llms.txt as a markdown-native sitemap curated specifically for Large Language Models (LLMs).

When an AI crawler (like GPTBot, PerplexityBot, or ClaudeBot) visits your domain, it requests /llms.txt at your site root. Instead of crawling complex DOM trees and rendering heavy client-side JavaScript, the LLM reads a lightweight Markdown file that provides:

A concise overview of your product, documentation, or company.
Direct links to markdown versions of your core pages or documentation.
Machine-readable context for accurate citations.

📄 Structure of a Standard `llms.txt`

An llms.txt file follows a structured Markdown format:

# YourProjectName
> A concise, one-sentence summary of what your project or website does.

## Core Documentation
- [Quickstart Guide](https://example.com/docs/quickstart.md): Get started in 5 minutes.
- [API Reference](https://example.com/docs/api.md): Complete endpoints and data schemas.
- [Architecture Overview](https://example.com/docs/architecture.md): Deep dive into technical design.

## Optional & Full Context
- [Full LLM Documentation](https://example.com/llms-full.txt): Complete consolidated docs in one file.

🛠️ Implementing `llms.txt` in Next.js 15 (App Router)

If you are using Next.js 15 / 14, you can create a dynamic route at app/llms.txt/route.ts:

import { NextResponse } from "next/server";

export async function GET() {
  const content = `# My Web App
> High-performance developer platform.

## Documentation
- [Getting Started](https://myapp.com/docs/intro.md): Overview and installation.
- [Components](https://myapp.com/docs/components.md): UI kit documentation.
`;

  return new NextResponse(content, {
    headers: {
      "Content-Type": "text/plain; charset=utf-8",
      "Cache-Control": "public, max-age=86400, s-maxage=86400",
    },
  });
}

⚡ Free Tools for Generating & Validating `llms.txt`

Manually formatting markdown files can lead to broken links or improper heading hierarchy. You can use the free utilities available on GEOKit:

🛠️ llms.txt Generator: Visual form builder that instantly generates specification-compliant llms.txt files.
✅ llms.txt Validator: Test your live llms.txt URL against schema standards and check for link 404s.
📊 AI Readiness Checker: Run a comprehensive audit of your website's headings, metadata, and AI readability score.

🚀 Conclusion

Implementing llms.txt takes less than 10 minutes, but gives your site a substantial advantage in the emerging era of Generative Engine Optimization (GEO).

Are you already optimizing your website for AI search engines? Share your thoughts and questions in the comments below!

Parsing AutoCAD DWG Headers in Pure Client-Side JavaScript (Zero Uploads)

cadguide.tools — Mon, 17 Aug 2026 08:49:00 +0000

If you work with CAD drawings in enterprise environments, you know the pain: opening a heavy 2GB CAD application just to check whether a legacy .dwg file was saved in AutoCAD 2004, 2013, or 2024 format.

Most online "DWG converters" and checkers require users to upload confidential engineering drawings to a remote cloud server. In aerospace, defense, and architectural engineering, uploading proprietary IP to random third-party servers is a critical compliance violation.

Here is how we implemented a 100% private, client-side DWG binary header parser in vanilla JavaScript that resolves file versions in under 5 milliseconds.

🔍 Understanding the DWG Binary Signature

AutoCAD DWG is a proprietary binary format created by Autodesk. While parsing the full 3D B-Rep entities requires complex reverse-engineered C++ libraries (like Open Design Alliance or LibreDWG), the version specification is always located in the first 6 bytes of the binary header.

Every valid AutoCAD drawing starts with a magic 6-character ASCII string:

Byte Offset (Hex)	ASCII Magic Code	Compatible AutoCAD Releases	Internal Format Version
`0x00 - 0x05`	`AC1015`	AutoCAD 2000, 2000i, 2002	Release 15.0
`0x00 - 0x05`	`AC1018`	AutoCAD 2004, 2005, 2006	Release 18.0
`0x00 - 0x05`	`AC1021`	AutoCAD 2007, 2008, 2009	Release 21.0
`0x00 - 0x05`	`AC1024`	AutoCAD 2010, 2011, 2012	Release 24.0
`0x00 - 0x05`	`AC1027`	AutoCAD 2013, 2014, 2015, 2016, 2017	Release 27.0
`0x00 - 0x05`	`AC1032`	AutoCAD 2018, 2021, 2024, 2026	Release 32.0

⚡ Pure Client-Side Implementation

Instead of reading a 500MB file into memory, we use the HTML5 File.slice() API to request only the first 6 bytes:

export interface DWGVersionInfo {
  headerCode: string;
  autocadVersions: string;
  releaseYear: string;
  isModernFormat: boolean;
}

const DWG_MAP: Record<string, Omit<DWGVersionInfo, 'headerCode'>> = {
  'AC1032': { autocadVersions: 'AutoCAD 2018 - 2026', releaseYear: '2018+', isModernFormat: true },
  'AC1027': { autocadVersions: 'AutoCAD 2013 - 2017', releaseYear: '2013', isModernFormat: true },
  'AC1024': { autocadVersions: 'AutoCAD 2010 - 2012', releaseYear: '2010', isModernFormat: false },
  'AC1021': { autocadVersions: 'AutoCAD 2007 - 2009', releaseYear: '2007', isModernFormat: false },
  'AC1018': { autocadVersions: 'AutoCAD 2004 - 2006', releaseYear: '2004', isModernFormat: false },
  'AC1015': { autocadVersions: 'AutoCAD 2000 - 2002', releaseYear: '2000', isModernFormat: false },
};

export async function parseDWGHeader(file: File): Promise<DWGVersionInfo> {
  // Read ONLY the first 6 bytes — instantaneous even for multi-gigabyte files
  const slice = file.slice(0, 6);
  const buffer = await slice.arrayBuffer();
  const bytes = new Uint8Array(buffer);

  // Convert binary ASCII codes to string
  const headerCode = String.fromCharCode(...bytes);

  if (!DWG_MAP[headerCode]) {
    throw new Error(`Unsupported or corrupted DWG format code: ${headerCode}`);
  }

  return {
    headerCode,
    ...DWG_MAP[headerCode]
  };
}

🛡️ Why This Architecture Matters

Zero Privacy Risk: Drawing files never leave the engineer's local RAM. No network requests, no cloud uploads, and 100% GDPR/ITAR compliance.
Instant Response Time: Parsing takes less than 3 milliseconds, even on multi-gigabyte drawing sets.
No Infrastructure Overhead: Runs entirely on the user's browser, allowing our web app to scale to millions of monthly checks at $0 server cost.

You can test the live tool directly at CADGuide DWG Version Checker or explore our open comparison of 50+ alternatives at CADGuide.tools.

Why We Built a 100% Static Niche Directory for CAD/BIM Engineers (And How It Costs $0 to Run)

cadguide.tools — Sun, 07 Jun 2026 01:21:27 +0000

Finding the right software in specialized industries is surprisingly difficult. Take the CAD and BIM space: designers, architects, and engineering managers are facing sky-high annual subscriptions for standard drafting suites. Many want to look for 1:1 alternatives, but they are met with fragmented, outdated comparison forums, or directories cluttered with paid ads.

To address this, we built CADGuide.tools — a free, interactive, data-driven directory designed to match professionals with the right CAD software based on their operating system, budget types, dynamic block capabilities, and AutoLISP APIs.

As developers, our biggest constraint was hosting costs and server maintenance. We wanted this site to load instantly, handle thousands of pages, and remain $0/month to run.

Here is the tech stack and architecture choices we made to achieve a zero-server-load platform.

The Tech Stack

Framework: Next.js 16 (App Router)
Styling: Tailwind CSS v4 (with custom HSL-based glassmorphism and modern UI transitions)
Interactivity: React 19 + Lucide Icons + Base UI
Deployment: Static Site Generation (SSG) hosted on Vercel

1. 100% Static Exports with Zero Server Database

Instead of relying on a running relational database, which would introduce monthly cloud database bills and slow down page load times due to server-side roundtrips, we centralized all software specifications, feature matrix definitions, and comparison records in a typed JSON-like data structure (data.ts).

At build time, Next.js crawls this local dataset and pre-renders thousands of static HTML pages:

Comparison pages (e.g., /compare/zwcad-vs-gstarcad)
Alternative directories (e.g., /alternatives/autocad)
Feature-specific listings (e.g., /features/autolisp-api)

Because these are static files, they are deployed directly to edge CDNs. The site achieves a near-perfect lighthouse score and loads in milliseconds globally.

2. Dynamic Matchmaker Completely in React

Normally, a "software recommendation wizard" or matchmaker requires a backend database to query matching filters.

We moved all the recommendation logic into client-side React hooks. Since the dataset is extremely structured and lightweight, we bundle the filtered data list directly into the client bundle. The matchmaker filters through 50+ desktop and cloud-based CAD engines instantly as the user clicks checkboxes—no API calls, no loading spinners, and no database query costs.

3. Web-Assembly & Client-Side File Parsers

To drive traffic and backlinks, we built a suite of client-side engineering utilities. For example, our DWG Version Checker helps designers find out which year of AutoCAD generated a DWG file (which is notorious for causing compatibility errors).

Instead of uploading massive binary drawings to a server—which raises huge security concerns for intellectual property and increases our bandwidth costs—we process the files entirely on the user's browser. Using the HTML5 File API and JavaScript's DataView, we read the first 6 bytes of the binary header directly on the client side:


javascript
const reader = new FileReader();
reader.onload = function(e) {
  const arr = new Uint8Array(e.target.result);
  const header = String.fromCharCode.apply(null, arr.slice(0, 6));
  // Matches "AC1032" -> AutoCAD 2018-2027, "AC1027" -> AutoCAD 2013-2017, etc.
  console.log("DWG Version Header:", header);
};
reader.readAsArrayBuffer(file.slice(0, 6));