@opendirectory.dev/skills 0.1.0

package/skills/llms-txt-generator/README.md

@@ -0,0 +1,142 @@
+# llms-txt-generator
+
+<img width="1376" height="768" alt="llms-txt-generator" src="https://github.com/user-attachments/assets/7f549d0b-4d55-40a8-97c6-59510cc40b54" />
+
+Generate a standards-compliant `llms.txt` file for any website. Makes your site fully readable and citable by AI agents the GEO (Generative Engine Optimization) equivalent of having a great sitemap.
+
+## What It Does
+
+The skill crawls your website using Chrome DevTools, reads your actual pages, and produces a clean `llms.txt` file in the format specified by [Jeremy Howard's llms.txt standard](https://llmstxt.org). When AI agents (Claude, ChatGPT, Gemini) visit your site, they read `llms.txt` first to understand what you are and where to find authoritative content.
+
+**Without llms.txt:** AI agents guess, hallucinate, or cite competitors instead.  
+**With llms.txt:** AI agents cite your product correctly and know exactly where your docs, blog, and key pages live.
+
+## Two Modes
+
+### Codebase Mode (no Chrome needed)
+If you're inside a website's repo, the skill reads your source files directly pages, routes, blog posts, frontmatter, site config. It writes `llms.txt` straight to `public/` when you approve. No browser required.
+
+Supported frameworks: **Next.js** (pages + app router), **Astro**, **Nuxt**, **Gatsby**, **SvelteKit**, **Hugo**, **Jekyll**
+
+### Live Site Mode (Chrome or fetch fallback)
+If you only have the URL, the skill crawls the live site using Chrome DevTools MCP. Falls back to standard web fetch if Chrome isn't available.
+
+---
+
+## Requirements
+
+**Codebase Mode:** No extra setup. Just be inside the repo directory.
+
+**Live Site Mode:**
+- Chrome with remote debugging enabled (or any live URL skill will fall back to web fetch)
+- Chrome DevTools MCP server configured in your agent (optional, improves JS-rendered sites)
+
+## Setup
+
+### For Live Site Mode: Start Chrome with Remote Debugging
+
+**Mac:**
+```bash
+open -a "Google Chrome" --args --remote-debugging-port=9222
+```
+
+**Linux:**
+```bash
+google-chrome --remote-debugging-port=9222
+```
+
+**Windows:**
+```bash
+chrome.exe --remote-debugging-port=9222
+```
+
+### 2. Install Chrome DevTools MCP Server
+
+Follow the setup at: https://github.com/ChromeDevTools/chrome-devtools-mcp
+
+Add to your agent's MCP configuration:
+```json
+{
+  "mcpServers": {
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["-y", "@chrome-devtools/mcp-server"],
+      "env": {
+        "CHROME_DEBUGGING_PORT": "9222"
+      }
+    }
+  }
+}
+```
+
+### 3. Configure Environment (Optional)
+
+Copy `.env.example` to `.env` and fill in:
+```bash
+cp .env.example .env
+```
+
+`GITHUB_TOKEN` and `GITHUB_REPO` are only needed if you want the agent to automatically open a GitHub PR with the generated file.
+
+## How to Use
+
+**Codebase Mode** just be inside your project and ask:
+```
+"Generate an llms.txt for this site"
+"Add llms.txt to this project"
+"Make this site readable by AI agents"
+```
+
+The agent will detect your framework, read your pages and blog posts from source, generate `llms.txt`, and write it to the right directory (e.g. `public/llms.txt`) after you confirm.
+
+**Live Site Mode** provide a URL:
+```
+"Generate an llms.txt for https://yoursite.com"
+"Does https://yoursite.com have an llms.txt? If not, create one."
+```
+
+The agent will:
+1. Check if `llms.txt` already exists at the domain
+2. Crawl homepage, docs, blog, about, pricing, and API pages
+3. Generate `llms.txt` following the official spec
+4. Optionally generate `llms-full.txt` with full page content
+5. Save the file locally and give you deployment instructions
+6. Optionally open a GitHub PR if configured
+
+## Where to Deploy the File
+
+Place `llms.txt` at your web root so it's accessible at `https://yourdomain.com/llms.txt`:
+
+| Platform | File Location |
+|----------|--------------|
+| Next.js / Vercel | `/public/llms.txt` |
+| Astro | `/public/llms.txt` |
+| Nuxt | `/public/llms.txt` |
+| GitHub Pages | Repository root |
+| Hugo | `/static/llms.txt` |
+| WordPress | Upload via FTP to web root |
+
+## Output Files
+
+| File | Description |
+|------|-------------|
+| `llms.txt` | Structured link map. LLMs follow links to find content |
+| `llms-full.txt` | Full prose content of key pages. LLMs ingest everything at once |
+
+## Project Structure
+
+```
+llms-txt-generator/
+├── SKILL.md                          # Agent instructions
+├── README.md                         # This file
+├── .env.example                      # Environment variables template
+├── evals/
+│   └── evals.json                    # Test prompts for skill evaluation
+└── references/
+    ├── llms-txt-spec.md              # The llms.txt format specification
+    └── output-template.md            # Exact output template with example
+```
+
+## License
+
+MIT

package/skills/llms-txt-generator/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: llms-txt-generator
+description: Generates and maintains a standards-compliant llms.txt file for any website — either by crawling the live site OR by reading the website's codebase directly. Use this skill when asked to create an llms.txt, add AI discoverability to a site, improve GEO (Generative Engine Optimization), make a website readable by AI agents, generate an llms-full.txt, check if a site has llms.txt, or audit a site's AI readiness for generative search. Trigger this skill any time a user mentions llms.txt, AI discoverability, LLM site readability, or wants their site to appear in AI-generated answers. Also trigger when the user is inside a website codebase and asks about SEO, AI readiness, or content structure.
+compatibility: [claude-code, gemini-cli, github-copilot]
+author: OpenDirectory
+version: 1.0.0
+---
+
+# llms.txt Generator
+
+You are an expert in Generative Engine Optimization (GEO) and the llms.txt standard. Your job is to crawl a website and produce a perfectly structured `llms.txt` file that makes the site fully readable and citable by AI agents.
+
+**CRITICAL RULE: DO NOT INVENT CONTENT.** Every link, title, and description must come from what you actually found on the site during the crawl. Never fabricate URLs or describe content you did not visit.
+
+**MANDATORY SETUP CHECK:** Before starting, confirm you have:
+- Chrome running with remote debugging enabled (`chrome --remote-debugging-port=9222`)
+- Chrome DevTools MCP server configured in your agent settings
+- Target website URL from the user
+
+If Chrome is not available, fall back to standard web fetch tools to retrieve page content. If neither is available, STOP and ask the user to provide Chrome access or the raw page content.
+
+---
+
+## Workflow
+
+### Step 1: Detect Source — Codebase or Live Site?
+
+Before anything else, check whether you are inside a website codebase:
+
+1. Look for `package.json`, `astro.config.*`, `next.config.*`, `nuxt.config.*`, `gatsby-config.*`, `vite.config.*`, or `_config.yml` in the current working directory or its parent.
+2. If found → **Codebase Mode** (go to Step 2A).
+3. If not found → ask the user for the target URL and proceed to **Step 2B**.
+
+---
+
+### Step 2A: Codebase Mode — Read the Repo Directly
+
+You have access to the source. Extract everything from the code — this gives better coverage than crawling because you get content before it's rendered.
+
+**2A-1. Detect the framework and site config:**
+- Read `package.json` → identify framework (next, astro, nuxt, gatsby, @sveltejs/kit, etc.) and the `name`/`description` fields
+- Read framework config file (`next.config.*`, `astro.config.*`, etc.) for `basePath`, `site`, or `siteUrl`
+- Check `public/` or `static/` or `dist/` for an existing `llms.txt` — if found, read it
+- **QA:** What framework is this? What is the base URL? Does llms.txt already exist?
+
+**2A-2. Discover all pages/routes:**
+
+| Framework | Where to look |
+|-----------|--------------|
+| Next.js (pages router) | `pages/**/*.tsx`, `pages/**/*.jsx` — skip `_app`, `_document`, `api/` |
+| Next.js (app router) | `app/**/page.tsx`, `app/**/page.jsx` — directory name = route |
+| Astro | `src/pages/**/*.astro`, `src/pages/**/*.md` |
+| Nuxt | `pages/**/*.vue` |
+| Gatsby | `src/pages/**/*.tsx`, `src/pages/**/*.jsx` |
+| SvelteKit | `src/routes/**/+page.svelte` |
+| Hugo / Jekyll | `content/**/*.md`, `_posts/**/*.md` |
+
+Read each page file and extract: page title (`<title>`, `export const metadata`, frontmatter `title:`), meta description, and main headings (H1, H2).
+
+**2A-3. Find blog/content posts:**
+- Check `content/`, `posts/`, `src/content/`, `_posts/`, `blog/` for markdown/MDX files
+- Read frontmatter (`title`, `description`, `date`, `slug`) from each file
+- List the 5–10 most recent or most important posts
+
+**2A-4. Read the site's existing SEO/meta config:**
+- `src/config.ts`, `src/site.config.ts`, `seo.config.*`, or any file exporting `siteTitle`, `siteDescription`, `siteUrl`
+- `constants.ts`, `config/index.ts` — look for site-level metadata
+
+**2A-5. Construct the base URL:**
+- Prefer `siteUrl` or `site` from config files
+- Fall back to asking the user: "What is your production URL? (e.g. https://yoursite.com)"
+- **QA:** Is the base URL confirmed? All links in llms.txt must use the full absolute URL.
+
+Then skip to **Step 4** to generate the file using codebase data.
+
+---
+
+### Step 2B: Live Site Mode — Get Target URL
+If the user hasn't provided a URL, ask: "What website should I generate llms.txt for?"
+
+### Step 3: Check for Existing llms.txt (Live Site Mode only)
+Before crawling, check if the site already has one:
+1. Navigate to `[URL]/llms.txt`
+2. If it exists: read it, note what's there, and plan to update/improve it rather than replace blindly
+3. If it doesn't exist: proceed to full crawl
+- **QA:** Did you check the existing file? Note its status (missing / outdated / present and good).
+
+### Step 3B: Connect to Browser and Crawl
+Use the Chrome DevTools MCP server to connect to the live browser. Follow the same connection pattern as the chrome-cdp-skill:
+1. Connect to `http://localhost:9222` via Chrome DevTools MCP
+2. Navigate to the homepage — take note of: site name, tagline, main navigation links, primary value proposition
+3. Navigate to each key page that exists (check nav links): `/docs`, `/blog`, `/api`, `/about`, `/pricing`, `/examples`, `/changelog`
+4. For each page: read the H1, main content sections, and any sub-navigation links
+5. For the blog: read titles and descriptions of the 5-10 most relevant/recent posts
+
+If Chrome DevTools MCP is unavailable, fall back to fetching pages with standard web tools (curl, fetch). If the site returns 403, try adding a browser User-Agent header.
+- **QA:** Did you successfully load and read each page? List which pages you visited and which returned 404. Do not include 404 pages.
+
+### Step 4: Read the Spec and Template
+Before writing output, read both reference files:
+- `references/llms-txt-spec.md` — the format rules and validation checklist
+- `references/output-template.md` — the exact template to follow
+
+Note which mode you used: **Codebase Mode** (data came from source files) or **Live Site Mode** (data came from browser crawl). Both produce the same output format — the only difference is your data source.
+
+### Step 5: Generate llms.txt
+Using only content from your crawl, produce the `llms.txt` file:
+
+1. Write the H1 header (product/site name — factual, not tagline)
+2. Write the summary blockquote (1-3 sentences, factual, LLM-friendly — no marketing fluff)
+3. Add only the H2 sections that have real content on the site
+4. For each link: write a factual, content-dense description of what an LLM will find at that URL
+5. Apply the validation checklist from `references/llms-txt-spec.md` before finalizing
+- **QA:** Is every URL real and verified from the crawl? Is every description factual, not marketing copy? Is the file under 5,000 words? Fix any issues before proceeding.
+
+### Step 6: Check for llms-full.txt
+Ask the user: "Do you also want me to generate `llms-full.txt` with the full prose content of key pages included? This is larger but gives AI agents everything in one file."
+
+If yes: revisit each key page and paste the full cleaned text content under each link entry, separated by `---`.
+
+### Step 7: Save and Output
+1. Save `llms.txt` to the current working directory (or the user's project root if known)
+2. If `llms-full.txt` was requested, save that too
+3. Print the full contents of `llms.txt` in the conversation so the user can review it
+4. If the user's site is on GitHub, offer to open a PR to add the file to the repo root
+- **QA:** Is the file saved? Did you confirm the save path with the user?
+
+### Step 8: Placement Instructions
+
+**If Codebase Mode:** You know the framework — place the file immediately:
+
+| Framework | Action |
+|-----------|--------|
+| Next.js / Vercel | Write directly to `public/llms.txt` in the repo |
+| Astro | Write directly to `public/llms.txt` |
+| Nuxt | Write directly to `public/llms.txt` |
+| Gatsby | Write directly to `static/llms.txt` |
+| SvelteKit | Write directly to `static/llms.txt` |
+| Hugo | Write directly to `static/llms.txt` |
+| Jekyll | Write directly to root of repo as `llms.txt` |
+
+Ask the user: "I can write `llms.txt` directly to `public/llms.txt` in your repo. Should I do that now, or do you want to review it first?"
+
+If approved, write the file. Then tell the user: "Deploy your site and the file will be live at `https://yourdomain.com/llms.txt`."
+
+**If Live Site Mode:** Tell the user where to add it:
+```
+Place llms.txt at your web root so it's accessible at: https://yourdomain.com/llms.txt
+
+- Next.js / Vercel: put in /public/llms.txt
+- Astro / Nuxt / Gatsby / SvelteKit: put in /public/llms.txt
+- GitHub Pages: put in root of repo
+- Hugo / Jekyll: put in /static/llms.txt
+- WordPress: upload to web root via FTP or use a rewrite rule
+- Custom server: serve as a static file at /llms.txt
+```
+
+---
+
+## Output Quality Standards
+
+A great `llms.txt` file:
+- Has a factual H1 and a clear 2-3 sentence summary that an LLM could quote directly
+- Covers all major content areas the site actually has
+- Uses link descriptions that explain WHAT IS THERE, not what the company wants you to think
+- Is scannable in under 30 seconds
+- Contains no broken links, no redirect chains, no CDN asset URLs
+- Passes all checks in `references/llms-txt-spec.md`
+
+A bad `llms.txt` file:
+- Has marketing language ("our amazing API", "best-in-class docs")
+- Contains invented or guessed URLs
+- Is missing major sections of the site
+- Has empty or vague descriptions ("info about our product")
+
+

package/skills/llms-txt-generator/evals/evals.json

@@ -0,0 +1,35 @@
+{
+  "skill_name": "llms-txt-generator",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Generate an llms.txt file for opendirectory.dev — it's our product site and we want AI agents to be able to find and cite us in generative search results.",
+      "expected_output": "A valid llms.txt file with H1 header (OpenDirectory), a factual summary paragraph, and H2 sections for the site's actual content areas (Skills, Docs, About). All URLs verified from the real site. Descriptions are factual and information-dense, not marketing copy. File is under 5000 words.",
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "Check if https://vercel.com has an llms.txt file. If it does, review it and suggest improvements. If not, generate one.",
+      "expected_output": "Agent first checks vercel.com/llms.txt. If present: reads it, identifies gaps or outdated links, and produces an improved version. If missing: crawls the site and generates a complete llms.txt covering their docs, blog, changelog, and about pages.",
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "My startup's website is at https://linear.app and I want to make sure AI models like Claude and ChatGPT can find us properly. Can you create the llms.txt and llms-full.txt files for us?",
+      "expected_output": "Agent generates both llms.txt (structured link map) and llms-full.txt (full prose content of key pages). llms.txt covers Linear's docs, changelog, about, and blog. llms-full.txt includes actual prose from key pages. Agent provides deployment instructions for placing the files at the web root.",
+      "files": []
+    },
+    {
+      "id": 4,
+      "prompt": "I'm inside my Next.js app router project. Can you generate an llms.txt for it?",
+      "expected_output": "Agent detects Next.js app router from package.json and next.config.*. Reads app/**/page.tsx files to discover routes. Extracts page titles from metadata exports and frontmatter. Reads src/content/ or posts/ for blog post frontmatter. Asks for or infers the production URL. Generates a valid llms.txt with all real pages. Offers to write it directly to public/llms.txt.",
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "I have an Astro blog at src/pages/ with markdown posts in src/content/blog/. Generate llms.txt and put it in the right place.",
+      "expected_output": "Agent detects Astro from astro.config.* and package.json. Reads src/pages/**/*.astro for routes. Reads src/content/blog/*.md frontmatter for blog post titles, descriptions, and slugs. Constructs absolute URLs from siteUrl in astro.config. Generates llms.txt. Writes the file directly to public/llms.txt without asking for manual steps.",
+      "files": []
+    }
+  ]
+}

package/skills/llms-txt-generator/references/llms-txt-spec.md

@@ -0,0 +1,88 @@
+# llms.txt Specification
+
+Proposed by Jeremy Howard (fast.ai / answer.ai). See: https://llmstxt.org
+
+## Purpose
+
+`/llms.txt` is a markdown file at the root of a website that helps LLMs understand what the site is about and where to find authoritative content. It is the AI equivalent of `robots.txt` — but instead of telling crawlers what to avoid, it tells AI agents what to read.
+
+## Why It Matters
+
+When an AI agent is asked about a company or product, it may visit the site. Without `llms.txt`, the agent has to infer structure from HTML, JavaScript-heavy pages, and noise. With `llms.txt`, the agent gets a clean, structured, LLM-optimized summary in seconds.
+
+Missing `llms.txt` = invisible to AI agents and generative search (GEO failure).
+
+---
+
+## File Format
+
+The file MUST be valid Markdown. MUST be served at exactly: `https://yourdomain.com/llms.txt`
+
+### Required Elements
+
+**1. H1 Header — Site/Product Name**
+```markdown
+# Product Name
+```
+
+**2. Optional Summary Block (blockquote or plain paragraph)**
+```markdown
+> One-paragraph plain-English description of what this site is about. 
+> Written for an LLM, not for marketing. Factual, concise, no fluff.
+```
+
+**3. H2 Sections with Link Lists**
+Each section is an H2 heading followed by a list of links with descriptions:
+```markdown
+## Section Name
+
+- [Page Title](https://domain.com/page): One-sentence description of what this page contains.
+- [Another Page](https://domain.com/other): What an LLM will find here.
+```
+
+### Recommended Sections (use only what exists on the site)
+
+| Section | What to include |
+|---------|----------------|
+| `## Docs` | API reference, getting started, installation guides |
+| `## API` | API endpoints, SDKs, developer reference |
+| `## Blog` | Top 5-10 most relevant/recent blog posts |
+| `## Examples` | Code examples, tutorials, demos |
+| `## About` | Company, team, mission pages |
+| `## Pricing` | Pricing page if public |
+| `## Changelog` | Release notes, changelog |
+
+### Link Description Format
+
+Keep descriptions factual and information-dense. Write what an LLM would find there:
+
+**Good:**
+```markdown
+- [API Authentication](https://api.example.com/docs/auth): How to obtain and use API keys, OAuth 2.0 flow, token refresh, and rate limit headers.
+```
+
+**Bad:**
+```markdown
+- [API Authentication](https://api.example.com/docs/auth): Learn about our amazing auth system!
+```
+
+---
+
+## llms-full.txt (Optional)
+
+A second file at `/llms-full.txt` that contains the FULL prose content of key pages — suitable for LLMs that want to ingest everything at once rather than follow links.
+
+Format: same as `llms.txt` but with full page content pasted inline under each link, separated by `---`.
+
+---
+
+## Validation Checklist
+
+Before saving the output, check:
+- [ ] File starts with an H1 (site/product name)
+- [ ] Has at least one H2 section with links
+- [ ] Every link description is factual (no marketing fluff)
+- [ ] All URLs are absolute (https://...), not relative
+- [ ] No broken links (verify URLs resolve during crawl)
+- [ ] File is clean Markdown with no HTML tags
+- [ ] Under 5,000 words (LLMs have context limits)

package/skills/llms-txt-generator/references/output-template.md

@@ -0,0 +1,76 @@
+# llms.txt Output Template
+
+Use this exact structure when generating the output. Fill in real content from the crawled site.
+
+---
+
+## Template
+
+```markdown
+# [Site/Product Name]
+
+> [1-3 sentence factual description of what this product/service does. Written for an AI agent.
+> Include: what it is, who uses it, what problem it solves. No marketing language.]
+
+## Docs
+
+- [Getting Started](https://domain.com/docs/getting-started): [What an LLM finds here — setup steps, prerequisites, first integration]
+- [API Reference](https://domain.com/docs/api): [Endpoints, parameters, request/response formats, auth headers]
+- [Configuration](https://domain.com/docs/config): [All configuration options, environment variables, defaults]
+
+## API
+
+- [Authentication](https://domain.com/api/auth): [How to authenticate, API key format, OAuth if applicable]
+- [Endpoints](https://domain.com/api/endpoints): [List of available endpoints, HTTP methods, rate limits]
+- [SDKs](https://domain.com/docs/sdks): [Available SDKs, language support, installation commands]
+
+## Blog
+
+- [Post Title](https://domain.com/blog/post-slug): [What this post covers — topic, key insight, who it's for]
+- [Post Title](https://domain.com/blog/post-slug): [What this post covers]
+
+## Examples
+
+- [Example Name](https://domain.com/examples/name): [What this example demonstrates, language/framework used]
+
+## About
+
+- [About](https://domain.com/about): [Company background, founding year, mission statement if factual]
+- [Pricing](https://domain.com/pricing): [Pricing tiers, free tier details, enterprise option]
+```
+
+---
+
+## Rules for Filling This Template
+
+1. **Only include sections that actually exist on the site.** Skip Docs if there are no docs. Skip API if no public API.
+2. **Links must be real, verified URLs** from the crawl. Do not invent URLs.
+3. **Descriptions must be factual** — describe what content is there, not what the company claims it does.
+4. **Limit Blog section to top 5-10 posts** — most relevant or most recent. Do not list all posts.
+5. **Keep total file under 5,000 words.**
+6. **Do not include**: social media links, legal pages (ToS, Privacy) unless specifically relevant, redirect URLs, CDN asset URLs.
+
+---
+
+## Example: OpenDirectory.dev
+
+```markdown
+# OpenDirectory
+
+> OpenDirectory.dev is a unified directory of open-source agent skills and automation pipelines designed for autonomous AI agents. It provides a curated collection of pre-built skills that developers can integrate into Claude Code, Gemini CLI, and other AI agent environments. Skills are configured once and run autonomously without ongoing intervention.
+
+## Skills
+
+- [Browse All Skills](https://opendirectory.dev/skills): Full directory of available agent skills, searchable by category (Agent, CLI, Content, SEO, Scraper, API).
+- [cook-the-blog](https://github.com/Varnan-Tech/cook-the-blog): Autonomous pipeline that researches a company, generates cover images, writes MDX case studies, and pushes to a GitHub blog repository.
+- [google-trends-api-skills](https://github.com/Varnan-Tech/google-trends-api-skills): SEO keyword research using Google Trends data via SerpApi for developer-focused blog content.
+
+## Docs
+
+- [Documentation](https://opendirectory.dev/docs): How to install and use skills with Claude Code, Gemini CLI, and GitHub Copilot.
+- [Skill Specification](https://opendirectory.dev/docs/spec): The SKILL.md format specification — frontmatter fields, directory structure, compatibility.
+
+## About
+
+- [GitHub Repository](https://github.com/Varnan-Tech): Source code for all open-source skills.
+```

package/skills/llms-txt-generator/test-output/genzcareer.in/llms.txt

@@ -0,0 +1,31 @@
+# GenZCareer
+
+> GenZCareer (genzcareer.in) is an AI-powered career platform built for Gen Z job seekers — students, freshers, and early-career professionals. It provides tools to build ATS-optimized resumes, generate personalized cover letters, practice mock interviews with an AI voice interviewer, search job listings, and receive 24/7 AI career coaching. The platform combines AI content generation with job discovery and application tracking in a single workflow.
+
+## Tools
+
+- [AI Resume Builder](https://www.genzcareer.in/resume-builder): Build professional, ATS-optimized resumes with AI assistance. Offers 6+ templates, real-time ATS feedback, and unlimited exports on paid plans. Designed for students and freshers entering the job market.
+- [AI Cover Letter Generator](https://www.genzcareer.in/cover-letter): Generate personalized, ATS-optimized cover letters in minutes. Tailors each letter to the job description. Professional templates included.
+- [ATS Resume Checker](https://www.genzcareer.in/ats-checker): Analyzes a resume against ATS (Applicant Tracking System) requirements. Identifies formatting issues, keyword gaps, and compatibility problems before submission.
+- [AI Mock Interview](https://www.genzcareer.in/mock-interview): AI-powered voice interviewer that conducts practice job interviews. Provides real-time feedback and generates personalized questions based on the user's resume and target role. Covers technical, behavioral, and HR interview formats.
+- [Job Search](https://www.genzcareer.in/find-job): Search thousands of job listings across industries. Covers internships, entry-level positions, and experienced roles matched to user skills and preferences.
+- [AI Career Advice](https://www.genzcareer.in/career-advice): Personalized AI career coaching available 24/7. Covers resume optimization, interview preparation, salary negotiation, and career planning.
+- [AI Portfolio Builder](https://www.genzcareer.in/portfolio-builder): Generates a developer portfolio in seconds by importing data from GitHub or an existing resume. No manual setup required.
+- [Profile Image Generator](https://www.genzcareer.in/profile-image-generator): Generates professional profile photos suitable for LinkedIn and job applications.
+- [Job Tracker](https://www.genzcareer.in/tracker): Tracks job applications — status, follow-ups, deadlines — in a centralized dashboard.
+- [Recommended Jobs](https://www.genzcareer.in/recommended): AI-curated job recommendations matched to the user's profile, resume, and career goals.
+
+## Blog
+
+- [Gen Z Job Search Strategy 2025: Complete Playbook + Free Tracker](https://www.genzcareer.in/blog/2025-gen-z-job-search-funnel-playbook): Step-by-step job search funnel guide used by 847 graduates in 2025. Includes a free application tracker, resume templates, and proven strategies for students worldwide.
+- [ATS Resume Guide for Freshers 2025](https://www.genzcareer.in/blog/ats-resume-for-freshers-2025): ATS resume writing guide for Indian freshers with 25 bullet point examples, a free resume template, CGPA formatting guidelines, and campus placement tips.
+- [15 Free AI Certificates for Students Resume 2025](https://www.genzcareer.in/blog/15-free-ai-certificates-students-resume-2025): Curated list of 15 free AI certifications from Google, Microsoft, IBM, and AWS that students can add to their resume. Includes credential verification details.
+
+## Pricing
+
+- [Pricing](https://www.genzcareer.in/pricing): Three tiers — Free (20 AI credits/month, 3 resume exports, basic templates), Pro (200 AI credits/month, unlimited exports, 50 ATS analyses, all templates, priority support), Ultra Pro (unlimited everything, personal AI career coach, 1-on-1 consultations, expert resume review). 3-day free trial on all paid plans.
+
+## About
+
+- [About](https://www.genzcareer.in/about): Company mission — built by a founder who experienced the broken job search process firsthand. GenZCareer uses AI-driven matching, personalized tools, and structured career guidance to bridge the gap between qualified candidates and job opportunities.
+- [Contact](https://www.genzcareer.in/contact): Contact page for support and inquiries.