A Comprehensive Guide for Budget-Conscious Users in Oriental Regions

Prahlad Yeri · June 15, 2026 · 47 min read

Note: This article was written with AI assistance.

For technical students, freelance coders, power users, and small businesses who want Claude-level productivity from budget-tier models.

Table of Contents

1. Introduction — The Budget-Conscious Developer’s Dilemma
2. The Art of Translating Intentions to Prompts
3. General LLM Usage Efficiency Principles
4. Model Classification Guide
5. Grammar and Language Efficiency When Talking to LLMs
6. Catalog of Example Prompts and Conversations
7. Free and Budget API Providers
8. Building Your Desktop Power-User Tooling
9. Regional Considerations and Final Thoughts

1. Introduction

If you are a developer or student in Bangalore, Jakarta, Manila or Hanoi, you already know the economics: the models that impress the tech press cost $15–$75 per million output tokens. At Indian freelance rates or a student budget, that is simply not viable for daily heavy use.

The good news is that the capability gap between the top tier and the budget tier has compressed dramatically today. GPT-4.1-mini, DeepSeek-V3, Phi-4, Mistral Small, Llama-3.3-70B, and Gemini Flash can handle 80–90% of a working developer’s daily tasks with no meaningful quality difference — if you know how to prompt them correctly.

This guide is about that 80–90% recovery rate. It will teach you:

• How to translate your technical intentions into tight, effective prompts
• Which model to reach for based on task type (and which to avoid)
• How to write efficient English prompts regardless of your native language
• Where to get generous free or cheap API access
• How to build your own multi-provider desktop tool as a power user

No fluff. No “imagine you are a helpful assistant.” Just practical craft.

2. The Art of Translating Intentions to Prompts

2.1 The Intention-to-Prompt Pipeline

Every prompt starts with an intention in your head — a problem you want solved. Most people make the mistake of transcribing that intention directly as a conversational sentence. Budget models, with their smaller context windows and leaner attention, benefit enormously from structured rather than conversational prompts.

Think of it as a three-stage pipeline:

[Raw Intention] → [Decomposed Problem] → [Structured Prompt]

Stage 1: Raw Intention

“I want to know why my React app’s state is not updating when I click a button.”

Stage 2: Decomposed Problem

• What is the observable symptom? Button click → no state update
• What is the suspected component? useState hook
• What is the environment? React 18
• What output do I want? Diagnosis + fix

Stage 3: Structured Prompt

“React 18. useState. Button click handler sets state but component does not re-render. No error in console. Explain top 3 causes and fix for each. Show code.”

Notice the transformation: 22 words down from a long conversational sentence, yet more information is packed in because every word carries signal.

2.2 The Four Dimensions of a Good Prompt

Every effective prompt for a budget model addresses four dimensions:

Not every prompt needs all four — trivia lookups may only need Context + Task. But code generation tasks almost always need all four for budget models to stay on track.

2.3 Common Anti-Patterns to Eliminate

Anti-Pattern 1: The Verbose Introduction

❌ "Hello! I hope you are doing well. I have been working on a project and I ran into a problem that I would like your help with. Specifically, I am building a React application and..."

✅ "React 18 app. Problem: [specific issue]. Need: [specific output]."

Budget models have smaller effective context windows. Every token of social nicety is a token stolen from actual reasoning.

Anti-Pattern 2: The Ambiguous Task

❌ "Can you help me with my Express.js code?"

✅ "Express.js 4. POST /login route. Need JWT issuance on success, 401 on failure. No Passport.js. Show complete route handler."

“Help me” is zero information. Budget models cannot infer your specific problem from genre alone.

Anti-Pattern 3: Overloading One Prompt

❌ "Build me a full React app with login, dashboard, and data table that connects to my Firebase backend with authentication, and also explain how Firebase works, and add tests."

This will produce mediocre output across all components. Split it:

1. Prompt 1: Firebase Auth integration hook
2. Prompt 2: Login page using that hook
3. Prompt 3: Dashboard layout with sidebar
4. Prompt 4: DataTable component

Better output, cheaper cost per useful token.

Anti-Pattern 4: Assuming Model Memory in Long Sessions

Budget models (especially via free-tier APIs with small context limits) forget earlier conversation. Do not assume the model remembers your stack or constraints from 10 messages ago. Re-state the key context in any new sub-task.

Anti-Pattern 5: Asking for Explanations When You Want Code

❌ "How do I implement debounce in React?"

✅ "React hook: useDebounce(value, delay). TypeScript. Return debounced value. Code only, no explanation."

Explanations cost tokens and latency. If you only want the code, say so.

3. General LLM Usage Efficiency Principles

3.1 Context Economy

Context economy is the discipline of maximizing signal-to-noise ratio in your prompts. Think of the model’s context window as RAM — expensive, limited, and shared between your input and its output.

Principles of Context Economy:

1. Paste only the relevant code, not the entire file. If your bug is in a 500-line file, paste only the relevant function (30 lines) plus the error message.

2. Use placeholders for boilerplate. Instead of pasting full component trees, write [Standard Navbar component] or [Firebase config object — standard setup].

3. State the stack once at the top of a session. Begin a session with a compact stack declaration:

   Stack: React 18 + Vite + TypeScript + Tailwind 3 + Firebase 10. All responses assume this unless overridden.

4. Request minimal output. Add "Code only. No explanation." or "Return only the changed function, not the full file." to keep output compact and cheap.

5. Avoid pleasantries in follow-ups. In a multi-turn session, follow-up messages like "That's great! Now can you..." waste tokens. Just "Now add error handling to that hook." works equally well.

3.2 Prompt Framing Techniques by Use Case

Different task categories have different optimal prompt frames:

The Debug Frame

Language/Framework: [X]
Error: [paste exact error message]
Code: [paste minimal reproduction]
Already tried: [what failed]
Need: root cause + fix

The Generation Frame

Task: [verb] [noun]
Stack: [technologies]
Requirements:
- [requirement 1]
- [requirement 2]
Constraints: [what NOT to use or do]
Output: [specific format — function, class, full component, etc.]

The Explanation Frame

Concept: [X]
My understanding: [what you think you know]
Unclear: [specific point of confusion]
Audience level: [beginner/intermediate/expert]
Format: [bullet list / analogy / step-by-step]

The Review Frame

Code: [paste code]
Review for: [bugs / performance / security / style / all]
Audience: [junior dev who will read this / production code]
Return: inline comments + summary of issues

The Refactor Frame

Code: [paste code]
Goal: [what you want improved — readability / performance / testability]
Preserve: [what must not change — API contract / function signature]
Constraints: [no new dependencies / same language version]

3.3 Iterative Refinement vs. One-Shot Prompting

One-shot prompting means getting your full answer in a single prompt. This is efficient for simple tasks but unreliable for complex ones with budget models.

Iterative refinement breaks complex tasks into rounds:

Round 1 → Skeleton / structure
Round 2 → Core logic implementation
Round 3 → Edge case handling
Round 4 → Types / documentation

The per-round cost is low because each prompt is smaller. The total output quality is higher because the model is never overloaded.

Rule of thumb: If describing your task takes more than 3 sentences, use iterative refinement.

4. Model Classification Guide

4.1 Understanding the Capability Tiers

Budget models fall into roughly four performance bands:

The key insight: strong budget models are excellent for 80% of daily developer work. You only need premium for long-document reasoning, novel architecture decisions, or highly nuanced technical writing.

4.2 Technical Assistance and Coding Lookups

“Glorified Stack Overflow” use case — you know roughly what you need, you want a quick answer with context-aware explanation.

Best models:

• DeepSeek-V3 — Excellent coding knowledge, very cheap, handles complex syntax questions well
• Llama-3.3-70B (via Groq) — Fast, reliable for framework-specific questions
• GPT-4.1-mini — Solid across all major frameworks; good at explaining why

Prompting strategy for this case:

• Be specific about the framework version
• Paste the exact error message
• State what you already tried
• Do not ask it to write an entire app — just the answer to your specific question

Example:

Express.js 4.18. Multer 1.4.5. Single file upload to /mnt/uploads.
Error: "MulterError: Unexpected field"
Field name in my form: "profileImage"
Multer config: upload.single('avatar')
Fix?

Avoid for this use case:

• Phi-3-mini, Llama-3.2-3B (too small for nuanced framework knowledge)
• GPT-4o for simple questions (overkill, expensive)

4.3 Trivia and Information Lookups

“Glorified Wikipedia” use case — factual questions, concept explanations, history, definitions, comparisons.

Best models:

• Gemini 1.5 Flash (via AI Studio free tier) — Excellent general knowledge, fast, free
• Llama-3.1-8B (via Groq) — Surprisingly good for factual recall at minimal cost
• Mistral Small — Good for structured information extraction

Prompting strategy:

• These models respond well to simple direct questions
• Add "Short answer." or "Bullet list, 5 points max." to avoid verbose responses
• For Indian/regional topics (GST rules, MSME schemes, Aadhaar integration), DeepSeek-V3 trained on broader Asian web data often outperforms GPT-4.1-mini

Avoid for this use case:

• Do not use large code-optimized models like DeepSeek-Coder for Wikipedia-style questions; you’re paying for code capability you don’t need

4.4 Code Generation — Modern Stacks

React, Tailwind, TypeScript, Node.js, Next.js, Cloudflare Workers, Firebase

This is where the capability gap between tiers is smallest. Budget models have ingested enormous training data on these popular stacks.

Recommended models (ranked):

1. DeepSeek-V3 — Best overall for full component generation. Understands Tailwind utility patterns, TypeScript generics, React hooks idioms. Often matches Claude Sonnet quality on React/TS tasks.
2. GPT-4.1-mini — Reliable, fast, well-calibrated for Next.js, App Router, RSC patterns
3. Llama-3.3-70B — Strong at standard React patterns; slightly weaker on cutting-edge Next.js 14+ features
4. Mistral Medium — Good for generating structured utility functions, custom hooks

Prompting strategy for React/Tailwind generation:

Declare your design system constraints upfront:

Stack: React 18, TypeScript, Tailwind 3, shadcn/ui
Component: [ComponentName]
Props interface: [describe or paste interface]
Behavior: [what it does]
Variants: [list visual variants if any]
Constraints: no external state management, props only
Output: complete TSX file with types

For Cloudflare Workers / Hono / D1: DeepSeek-V3 has strong coverage of the Cloudflare ecosystem (Workers, D1, KV, R2). GPT-4.1-mini sometimes has slightly outdated Hono v4 patterns — always specify the version.

For Firebase: Any strong budget model handles Firebase 10 (modular SDK) well. Specify "Firebase 10 modular SDK" explicitly — models default to older namespaced API patterns if you don’t.

4.5 Code Generation — Legacy Projects

WinForms, VB6, FoxPro, Delphi, Classic ASP, VBA

This is a genuinely hard use case for all budget models — and even for premium ones. Legacy code is underrepresented in training data, documentation is sparse online, and the idioms are unusual.

Ranked recommendations:

1. GPT-4.1-mini — Best legacy coverage among budget models. Knows WinForms well. Reasonable VB6 and VBA. FoxPro is hit or miss.
2. DeepSeek-V3 — Strong on WinForms/.NET, weaker on pre-.NET Microsoft technologies (VB6, FoxPro)
3. Llama-3.3-70B — Adequate for WinForms but prompting must be very specific
4. Mistral Small — Avoid for legacy work; insufficient training data

Specific legacy guidance:

WinForms (.NET Framework 4.x or .NET 6+):

• Specify "WinForms .NET Framework 4.8" or "WinForms .NET 6" — they have different idioms
• Be explicit: "Use Windows Forms Designer-compatible code (partial classes, InitializeComponent)" if you need designer-compatible output
• State whether you use async/await (not all WinForms projects do)

VB6:

• GPT-4.1-mini is your best bet but it is not reliable
• Always specify "VB6 (not VB.NET)" explicitly — models default to VB.NET
• Paste the existing code style so the model can mimic it
• Validate all generated VB6 code carefully; models hallucinate APIs that don’t exist in VB6

FoxPro / Visual FoxPro:

• No budget model handles FoxPro well; even GPT-4o struggles
• Use the model for logic only (algorithm design, SQL translation) and write the FoxPro syntax yourself
• Prompt: "I need this logic in pseudocode/SQL. I will translate to FoxPro myself."

Delphi / Object Pascal:

• GPT-4.1-mini has reasonable Delphi coverage for standard VCL patterns
• DeepSeek-V3 is surprisingly capable for Delphi (possibly due to more Asian developer training data)
• Specify: "Delphi 10.x (RAD Studio). VCL, not FMX."

4.6 Technical Documentation and Book Writing

Writing technical books, course materials, API documentation, README files, and tutorials.

Recommended models:

1. DeepSeek-V3 — Outstanding for technical writing. Produces well-structured, accurate prose with good terminology. Excellent for Indian/Asian market technical content.
2. GPT-4.1-mini — Very clean prose, good at following style guides, strong at README generation
3. Mistral Medium — Good for European/formal documentation style; less natural for Indian-English conventions
4. Llama-3.3-70B — Good prose but occasionally verbose; budget for extra editing

Prompting strategy for documentation:

Document type: [API reference / tutorial / conceptual guide / README]
Audience: [experience level + background]
Technology: [specific stack]
Tone: [formal / approachable / terse]
Structure: [provide outline or ask model to generate one first]
Length: [word count or section count target]
Include: [code examples / diagrams as ASCII / callouts]
Exclude: [marketing fluff / excessive disclaimers]

For book writing specifically:

• Always generate chapter outlines first, review them, then generate section by section
• Budget models drift in tone over long outputs — regenerate section by section with a tone anchor in each prompt
• Keep a “style reference” snippet from your best-written section and paste it into subsequent prompts: "Match this writing style: [paste 2 paragraphs]"

4.7 Product Comparisons for the Indian/Oriental Market

Comparing software, hosting, payment gateways, accounting tools, cloud services — with Indian/regional market context (pricing in INR, GST implications, Indian compliance, regional support quality, etc.)

Recommended models:

1. DeepSeek-V3 — Best for India/Asia market context. Strong coverage of Indian cloud providers (AWS India, Azure India), Indian SaaS (Zoho, Tally, Razorpay), and regional compliance requirements
2. Gemini 1.5 Flash (Google AI Studio) — Google’s model has strong coverage of Indian market due to Google’s deep India presence; good for Google Workspace, Google Cloud India comparisons
3. GPT-4.1-mini — Global coverage is excellent; India-specific nuance (e.g., GST implications of SaaS subscriptions, MSME portal comparisons) is sometimes shallow
4. Llama-3.3-70B — Adequate for technology comparisons; weaker on pricing accuracy for Indian market

Prompting strategy:

Compare: [Product A] vs [Product B] vs [Product C]
Context: Indian [MSME / startup / freelancer / enterprise]
Criteria:
- Pricing (INR, include GST)
- Indian payment support (UPI, Razorpay, CC Avenue)
- GST compliance / e-invoicing support
- Indian customer support quality
- [additional criteria]
Output: comparison table then recommendation

Important caveat: Always verify pricing independently. All models have training cutoffs and Indian SaaS pricing changes frequently.

4.8 Quick Reference Matrix

5. Grammar and Language Efficiency

5.1 Economical English for Non-Native Speakers

One of the biggest advantages of prompting an LLM is that it does not need polished English. It needs precise English. These are different things.

A developer in Bengaluru or Manila whose first language is Kannada or Tagalog often writes prompts that are grammatically perfect but informationally sparse, because they’ve been trained to write politely in a second language. The inverse of what you need.

Core principle: Sacrifice grammar before sacrificing precision.

An LLM will parse "function not working, undefined variable but variable exist in parent scope" correctly. It will not correctly parse "I seem to be experiencing an issue with my variable which I believe might be related to scope, although I am not entirely certain." The second sentence is grammatically superior and informationally inferior.

5.2 Sentence Patterns That Work Best

LLMs are effectively text-completion engines trained on human writing. Certain prompt structures pattern-match strongly to the kind of technical documents they were trained on, pulling higher-quality completions.

Pattern 1: Telegram Style Omit articles, conjunctions, filler. Use only nouns, verbs, and technical terms.

TypeScript. Generic type constraint. Function accepts array of objects. Return type infers from input. Show syntax.

Pattern 2: Spec-List Style Use a short problem statement followed by a bulleted spec. Models trained on GitHub issues and Stack Overflow answers respond well.

`Build Express.js middleware:

• Validates JWT from Authorization header
• Attaches decoded payload to req.user
• Returns 401 if missing or invalid
• Handles expired token specifically (403)
• TypeScript, no Passport.js`

Pattern 3: Fill-in-the-Blank Style Give the model a template to complete.

Complete this React hook: useLocalStorage(key: string, defaultValue: T) → [value: T, setValue: (v: T) => void]. Should sync across tabs. TypeScript.

Pattern 4: Before/After Style For refactoring and transformation tasks, show what you have and what you want.

Transform this: [paste code] Into: same logic but using async/await instead of .then() chains. Preserve function signatures.

5.3 Words and Phrases to Eliminate

These add length and reduce clarity with budget models:

5.4 Structured Prompt Templates

Copy and adapt these templates for daily use:

Template A: Quick Code Lookup

[Technology + Version]. [Problem in one sentence]. [Error message if any]. Fix?

Template B: Component/Function Generation

[Stack declaration]. 
[Component/function name and signature].
Requirements: [bulleted list].
Output: [code only / with tests / with types / full file].

Template C: Debugging

[Language/framework].
Error: [paste error].
Code: [paste minimal snippet].
Expected: [what should happen].
Actual: [what happens instead].
Tried: [what you already attempted].

Template D: Explanation Request

Explain [concept] to a [junior / mid-level / senior] developer.
Focus on: [specific aspect].
Use: [analogies / code example / both].
Length: [2 paragraphs / bullet list / step-by-step].

Template E: Technical Writing

Write [section type] for [topic].
Audience: [description].
Tone: [formal / conversational].
Include: [specific elements].
Length: ~[word count].

Template F: Code Review

Review this [language] code.
Check for: [bugs / security / performance / readability].
[Paste code].
Return: list of issues with line references and fixes.

6. Catalog of Example Prompts and Conversations

6.1 Coding Help Lookups

Example 1: React State Bug

User: React 18. useState. Updating array state by pushing to existing array — 
      component not re-rendering. Using: setArr(arr.push(newItem))
      Why? Fix?

Model: arr.push() mutates the original array and returns the new length (a number), 
       not the new array. useState only re-renders when it receives a new reference.

Fix:
  setArr([...arr, newItem])       // spread (most common)
  setArr(prev => [...prev, newItem]) // functional update (safer for async contexts)

Rule: Never mutate state directly. Always create new array/object.

Analysis: 24 tokens of prompt, precise answer, zero wasted tokens.

Example 2: Cloudflare D1 Query

User: Cloudflare D1. Wrangler 3. TypeScript Worker.
      Batch insert 500 rows. Using db.batch() — hitting "too many SQL variables" error.
      Schema: users(id TEXT, name TEXT, email TEXT, created_at TEXT)
      Current code: one prepare().bind() per row in batch array.
      Fix?

Model: D1's SQLite has a variable limit (~32766). With 3 bound params per row × 500 rows 
       = 1500 variables — within limits usually, but batch() itself has a statement count 
       limit (~100 statements per batch).

Fix: Chunk your batch into groups of 100:
  
  const chunkSize = 100;
  for (let i = 0; i < rows.length; i += chunkSize) {
    const chunk = rows.slice(i, i + chunkSize);
    await db.batch(
      chunk.map(row =>
        db.prepare("INSERT INTO users VALUES (?, ?, ?, ?)")
          .bind(row.id, row.name, row.email, row.created_at)
      )
    );
  }

Example 3: TypeScript Generic Constraint

User: TypeScript. Generic function. Want to accept any object with an "id" field 
      (string or number). Return same object type. Syntax?

Model: 
  function findById<T extends { id: string | number }>(items: T[], id: T['id']): T | undefined {
    return items.find(item => item.id === id);
  }

  // Usage:
  const users = [{ id: 1, name: 'Ravi' }, { id: 2, name: 'Priya' }];
  const user = findById(users, 1); // type: { id: number; name: string } | undefined

6.2 Code Generation — React/Tailwind

Example 4: Custom Hook with Full Spec

User: Stack: React 18, TypeScript.
      Hook: useDebounce<T>(value: T, delay: number): T
      - Returns debounced value after delay ms
      - Cleans up on unmount
      - Resets timer if value changes before delay
      Code only, no explanation.

Model:
  import { useState, useEffect } from 'react';

  function useDebounce<T>(value: T, delay: number): T {
    const [debouncedValue, setDebouncedValue] = useState<T>(value);

    useEffect(() => {
      const timer = setTimeout(() => {
        setDebouncedValue(value);
      }, delay);

      return () => {
        clearTimeout(timer);
      };
    }, [value, delay]);

    return debouncedValue;
  }

  export default useDebounce;

Example 5: Tailwind Component with Variants

User: React + Tailwind 3 + TypeScript.
      Component: Badge
      Props: label (string), variant ('success' | 'warning' | 'error' | 'info'), size ('sm' | 'md')
      Design: pill shape, solid background per variant
      Colors: success=green, warning=yellow, error=red, info=blue (use Tailwind 500-level)
      No external libraries. TSX file only.

Model:
  interface BadgeProps {
    label: string;
    variant: 'success' | 'warning' | 'error' | 'info';
    size?: 'sm' | 'md';
  }

  const variantClasses: Record<BadgeProps['variant'], string> = {
    success: 'bg-green-500 text-white',
    warning: 'bg-yellow-500 text-white',
    error: 'bg-red-500 text-white',
    info: 'bg-blue-500 text-white',
  };

  const sizeClasses: Record<NonNullable<BadgeProps['size']>, string> = {
    sm: 'px-2 py-0.5 text-xs',
    md: 'px-3 py-1 text-sm',
  };

  export default function Badge({ label, variant, size = 'md' }: BadgeProps) {
    return (
      <span
        className={`inline-flex items-center rounded-full font-medium
          ${variantClasses[variant]} ${sizeClasses[size]}`}
      >
        {label}
      </span>
    );
  }

6.3 Legacy Code WinForms/.NET

Example 6: WinForms Async Operation with Progress

User: WinForms .NET Framework 4.8. C#.
      Button click triggers long database operation.
      Need: UI stays responsive, progress bar updates, cancel button works.
      Use: async/await + CancellationToken.
      No BackgroundWorker (old pattern).
      Show complete button handler + progress update pattern.

Model:
  private CancellationTokenSource? _cts;

  private async void btnProcess_Click(object sender, EventArgs e)
  {
      btnProcess.Enabled = false;
      btnCancel.Enabled = true;
      progressBar.Value = 0;
      _cts = new CancellationTokenSource();

      try
      {
          await ProcessDataAsync(_cts.Token);
          MessageBox.Show("Done!");
      }
      catch (OperationCanceledException)
      {
          MessageBox.Show("Cancelled.");
      }
      catch (Exception ex)
      {
          MessageBox.Show($"Error: {ex.Message}");
      }
      finally
      {
          btnProcess.Enabled = true;
          btnCancel.Enabled = false;
          _cts.Dispose();
          _cts = null;
      }
  }

  private async Task ProcessDataAsync(CancellationToken token)
  {
      var progress = new Progress<int>(value =>
      {
          progressBar.Value = value;
          lblStatus.Text = $"Processing: {value}%";
      });

      await Task.Run(() => DoHeavyWork(progress, token), token);
  }

  private void DoHeavyWork(IProgress<int> progress, CancellationToken token)
  {
      for (int i = 0; i <= 100; i += 10)
      {
          token.ThrowIfCancellationRequested();
          Thread.Sleep(300); // replace with real work
          progress.Report(i);
      }
  }

  private void btnCancel_Click(object sender, EventArgs e)
  {
      _cts?.Cancel();
  }

Example 7: VB6 Legacy — Use Model for Logic Only

User: VB6 app. Need to parse a CSV file (comma-delimited, first row headers).
      Store data in a Collection of user-defined types.
      Give me the logic in pseudocode — I'll write the VB6 syntax.

Model:
  Pseudocode:
  
  1. Open file for sequential read
  2. Read first line → split by comma → store as headers array
  3. Initialize empty collection
  4. Loop: read each subsequent line until EOF
     a. Skip blank lines
     b. Split line by comma → values array
     c. Create new record UDT
     d. For each header index, assign values(index) to record field by name
     e. Add record to collection
  5. Close file
  6. Return collection

  Edge cases to handle:
  - Fields containing commas (wrap in quotes — check for leading " before splitting)
  - Empty last field (trailing comma)
  - CRLF vs LF line endings
  - File not found error

6.4 Technical Documentation

Example 8: README Section

User: Write README Installation section for:
      - Node.js CLI tool called "mdglance"
      - Requires Node 18+
      - Install via npm globally
      - Config file: ~/.mdglance.json (optional)
      - One optional env var: MDGLANCE_THEME
      Audience: developers on Windows/Mac/Linux.
      Format: markdown with code blocks.
      Tone: direct, not marketing-y.

Model:
  ## Installation

  Requires Node.js 18 or higher.

  ```bash
  npm install -g mdglance
  ```

  Verify installation:

  ```bash
  mdglance --version
  ```

  ### Configuration (optional)

  Create `~/.mdglance.json` to customize behavior:

  ```json
  {
    "theme": "dark",
    "fontSize": 14,
    "lineHeight": 1.6
  }
  ```

  If the config file is absent, defaults are used.

  ### Environment Variables

  | Variable | Description | Default |
  |----------|-------------|---------|
  | `MDGLANCE_THEME` | Override theme (`light` or `dark`) | `light` |

  `MDGLANCE_THEME` takes precedence over the config file value when set.

Example 9: API Reference Entry

User: Write API reference entry for this function:
      deleteUser(userId: string, options?: { soft?: boolean, reason?: string }): Promise<void>
      - Deletes user from database
      - soft: true moves to deleted_users table instead of permanent delete (default: false)
      - reason: stored in audit log
      - Throws UserNotFoundError if userId doesn't exist
      Format: JSDoc + prose description + parameter table + example.

Model:
  /**
   * Deletes a user record from the database.
   *
   * By default performs a hard delete (permanent). When `soft` is true, the record
   * is moved to the `deleted_users` table and can be restored. The `reason` string
   * is written to the audit log regardless of deletion type.
   *
   * @param {string} userId - The unique identifier of the user to delete.
   * @param {object} [options] - Optional deletion parameters.
   * @param {boolean} [options.soft=false] - When true, soft-deletes the record.
   * @param {string} [options.reason] - Reason for deletion, stored in the audit log.
   * @returns {Promise<void>}
   * @throws {UserNotFoundError} If no user with the given ID exists.
   *
   * @example
   * // Hard delete
   * await deleteUser('usr_abc123');
   *
   * // Soft delete with audit reason
   * await deleteUser('usr_abc123', { soft: true, reason: 'GDPR request' });
   */
  async function deleteUser(
    userId: string,
    options?: { soft?: boolean; reason?: string }
  ): Promise<void>

  ---

  **Parameters**

  | Name | Type | Required | Default | Description |
  |------|------|----------|---------|-------------|
  | `userId` | `string` | Yes | — | The user's unique ID |
  | `options.soft` | `boolean` | No | `false` | Move to deleted_users instead of permanent delete |
  | `options.reason` | `string` | No | — | Reason stored in audit log |

6.5 Indian Market Product Comparisons

Example 10: Payment Gateway Comparison

User: Compare Razorpay vs PayU vs Cashfree vs Instamojo for:
      - Indian MSME e-commerce (B2C, ₹5L–50L annual GMV)
      - Need: UPI, cards, netbanking, EMI
      - Priority: low settlement time, low fees, good support
      Table format. Recommend one.

Model:
  | Feature | Razorpay | PayU | Cashfree | Instamojo |
  |---------|----------|------|----------|-----------|
  | Transaction fee (cards) | 2% | 2% | 1.75% | 2% |
  | Transaction fee (UPI) | 0% (<₹2000) | 0% | 0% | 0% |
  | Settlement time | T+2 | T+2 | T+1/T+2 | T+2 |
  | Instant settlement | Yes (paid) | Yes (paid) | Yes (paid) | No |
  | MSME/startup dashboard | Excellent | Good | Good | Basic |
  | API/integration quality | Best-in-class | Good | Good | Basic |
  | International payments | Yes | Yes | Yes | Limited |
  | GST invoice | Auto-generated | Auto-generated | Auto-generated | Manual |
  | Support quality | Good (email/chat) | Average | Good | Below average |
  | Free plan | No | No | No | Yes (limited) |

  **Recommendation: Razorpay** for most Indian MSMEs in this GMV range.

  Rationale: The fee difference vs Cashfree (0.25%) is ₹125 per ₹50,000 — negligible. 
  Razorpay's developer experience, dashboard quality, and ecosystem integrations 
  (Shopify, WooCommerce, Zoho, Tally) save far more than that in setup and maintenance time.
  Cashfree is second choice if settlement speed (T+1) is critical.

6.6 Multi-Turn Conversation Strategies

Example 11: Building a Feature Incrementally

Turn 1 — Get the skeleton:

User: React 18 + TypeScript + Tailwind 3.
      Build: data table component with server-side pagination.
      Turn 1: Give me only the TypeScript interfaces and component signature. No implementation.

Turn 2 — Core implementation:

User: Good. Now implement the table body and pagination controls. 
      Use the interfaces from your last response.
      Data fetching: receive fetchPage(page: number, pageSize: number): Promise<PagedResult<T>> as prop.
      No loading state yet.

Turn 3 — Add loading and error:

User: Add loading state (skeleton rows during fetch) and error state (error message with retry button).
      Keep all existing logic intact. Show only the changed/added JSX and the updated state types.

Turn 4 — Extract to hook:

User: Extract the pagination and fetch logic into a custom hook: usePaginatedData(fetchPage, initialPage, pageSize).
      Keep the component lean — it should only call the hook and render.

This multi-turn approach produces a cleaner final result than asking for everything at once, and each individual prompt is small enough for even a budget model context window.

7. Free and Budget API Providers

7.1 Provider Catalog and Comparison

7.2 OpenRouter — The Universal Gateway

URL: https://openrouter.ai
Model: Pay-per-token but many models have free tiers; pricing visible per model

OpenRouter is arguably the single most important provider for budget-conscious power users. It is a unified API that routes to 200+ models from dozens of providers — all behind one OpenAI-compatible API format.

Why it matters for Oriental users:

• Single API key, single billing, single integration
• Easily switch models in your tooling without changing code
• Many models have :free routing variants (e.g., meta-llama/llama-3.3-70b-instruct:free)
• Transparent per-token pricing comparison across providers

Getting started:

# OpenRouter uses OpenAI-compatible API format
curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek/deepseek-chat",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Free models via OpenRouter:

• meta-llama/llama-3.3-70b-instruct:free
• google/gemma-2-9b-it:free
• mistralai/mistral-7b-instruct:free
• deepseek/deepseek-r1:free (reasoning model!)
• microsoft/phi-3-medium-128k-instruct:free

Pro tip: Set up model fallback routing in OpenRouter. If your primary model is rate-limited, it auto-falls to a backup.

Rate limits on free tier: Roughly 20 requests/minute, 200/day per free model. For production or heavy usage, add $5–$10 credit — you will not exhaust it quickly at budget model prices.

7.3 Groq — Ultra-Low Latency Inference

URL: https://console.groq.com
Free tier: Generous — 30 requests/minute, 6000 requests/day

Groq’s custom LPU (Language Processing Unit) hardware delivers inference at 400–800 tokens/second — 10–50× faster than GPU-based providers. For developers who need interactive speed in desktop tools, Groq is often the best choice.

Available models on Groq:

• llama-3.3-70b-versatile — Best all-round model; excellent for code and text
• llama-3.1-8b-instant — Ultra-fast, small tasks
• mixtral-8x7b-32768 — 32K context, good for document tasks
• gemma2-9b-it — Google’s model at Groq speed

Best use cases for Groq:

• Interactive autocomplete in desktop tools (low latency critical)
• Quick code lookups and debugging
• Trivia and explanation queries
• Chat interfaces where response speed = user experience

Code integration:

// Groq uses OpenAI-compatible format
import Groq from 'groq-sdk';

const groq = new Groq({ apiKey: process.env.GROQ_API_KEY });

const response = await groq.chat.completions.create({
  model: 'llama-3.3-70b-versatile',
  messages: [{ role: 'user', content: prompt }],
  temperature: 0.3,  // lower = more focused for coding
  max_tokens: 2048,
});

Indian context: Groq’s servers are in the US, but latency to Indian users is reasonable (~150–250ms to first token) compared to GPU providers which can be 2–5 seconds.

7.4 GitHub Models — Hidden Gem for Developers

URL: https://github.com/marketplace/models
Access: Free for GitHub users (requires account); limited rate on free tier

GitHub Models gives access to premium models (including GPT-4.1-mini, Phi-4, Meta-Llama, Mistral) through Azure AI Studio, authenticated via your GitHub token. This is significant: you get GPT-4.1-mini for free with a standard GitHub account.

Available models include:

• gpt-4.1-mini — OpenAI’s budget model, free via GitHub
• Phi-4 — Microsoft’s strong small model
• Meta-Llama-3.3-70B-Instruct
• Mistral-small
• AI21-Jamba-1.5-Mini

Integration:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://models.inference.ai.azure.com",
    api_key=os.environ["GITHUB_TOKEN"],  # your personal access token
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}],
)

Rate limits: 15 requests/minute, 150/day on free tier. Enough for prototyping and light professional use. Not enough for batch processing.

Key advantage: No credit card required. Perfect for students and first-time API users in India where international payment setup can be a friction point.

7.5 Google AI Studio — Gemini for Free

URL: https://aistudio.google.com
Free tier: 15 RPM (requests per minute), 1 million tokens/day for Gemini 1.5 Flash

Google AI Studio offers the most generous free tier of any major provider. Gemini 1.5 Flash is genuinely capable — competitive with GPT-4o-mini — and the 1M-token daily limit is almost impossible to exhaust in individual developer use.

Available free models:

• gemini-1.5-flash — Fast, capable, 1M context window
• gemini-1.5-flash-8b — Faster, smaller
• gemini-2.0-flash-exp — Newest model (experimental)

Unique advantages:

• 1 million token context window — Paste an entire codebase, full book chapter, or 100-page PDF
• Multimodal — Accepts images and PDFs natively
• Indian language support — Better Hindi/Tamil/Telugu comprehension than most models

Python integration:

import google.generativeai as genai

genai.configure(api_key=os.environ["GEMINI_API_KEY"])
model = genai.GenerativeModel('gemini-1.5-flash')

response = model.generate_content(prompt)
print(response.text)

Best use for Indian developers:

• Analyzing large documents (government PDFs, lengthy specifications)
• Hindi/regional language content generation
• Tasks requiring long context (entire project files, book chapters)
• General knowledge questions about the Indian market

Note on data privacy: Data sent to Gemini free tier may be used to improve Google’s models (per their terms of service). For confidential client code, use a paid tier or an alternative.

7.6 DeepSeek API — Chinese Model, Global Value

URL: https://platform.deepseek.com
Pricing: ~$0.14/M input tokens, ~$0.28/M output tokens for DeepSeek-V3 (among cheapest in class)

DeepSeek is a Chinese AI lab whose models punch significantly above their price point. DeepSeek-V3 often matches or exceeds GPT-4o on coding tasks at roughly 1/50th the price.

Why it matters for Oriental users:

• Pricing in USD is very cheap; at INR exchange rates, approximately ₹12/M input tokens
• Strong coverage of Asian market context (Indian, Chinese, SEA business scenarios)
• Best-in-class for technical coding tasks among budget providers
• DeepSeek-R1 (reasoning model) available free via OpenRouter

Available models:

• deepseek-chat (DeepSeek-V3) — Best general-purpose
• deepseek-coder — Optimized for code generation
• deepseek-reasoner (DeepSeek-R1) — Slow but capable reasoning

Integration (OpenAI-compatible):

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": prompt}]
)

Important consideration: DeepSeek is a Chinese company. For users with data sovereignty requirements (government contracts, sensitive enterprise data), use alternative providers. For typical freelance and MSME work, this is not a meaningful concern.

7.7 Other Notable Providers

Cerebras:

• URL: https://cloud.cerebras.ai
• Ultra-fast inference (similar to Groq) using custom Wafer Scale Engine chips
• Free tier: Llama-3.3-70B at ~2000 tokens/second
• Best for: Extremely fast interactive responses

Together AI:

• URL: https://api.together.xyz
• $25 free credit for new accounts
• Hosts 100+ open-source models
• Good for: Experimenting with Qwen, Yi, Falcon, and newer open models

Mistral AI:

• URL: https://console.mistral.ai
• No free tier but very competitive pricing
• Mistral Small: $0.20/M tokens — excellent for EU-hosted workflows with GDPR compliance
• Best for: European client work requiring EU-hosted models

Hugging Face Inference API:

• URL: https://huggingface.co/inference-api
• Free tier for many models (rate-limited)
• Best for: Experimenting with niche models; running sentence transformers, embeddings, classification

Perplexity API:

• URL: https://docs.perplexity.ai
• Unique: Real-time web search built in
• Models like sonar-pro can answer questions with current web data
• Best for: Research tasks, competitive intelligence, current event queries

8.1 Architecture for a Multi-Provider Desktop Client

A power-user LLM desktop client needs four components:

[UI Layer]          — Text input, chat history, model selector, output display
[Provider Abstraction] — Unified interface for all API providers
[Session Manager]   — Context/history management, prompt templates
[Storage Layer]     — Local prompt library, conversation history, API keys

The key design principle: all providers should be interchangeable behind one interface. Since every major budget provider (OpenRouter, Groq, DeepSeek, GitHub Models, Gemini) offers an OpenAI-compatible API, this is achievable with minimal code.

Unified provider interface (TypeScript):

interface LLMProvider {
  id: string;
  name: string;
  baseUrl: string;
  defaultModel: string;
  models: string[];
  apiKeyEnvVar: string;
}

const PROVIDERS: LLMProvider[] = [
  {
    id: 'openrouter',
    name: 'OpenRouter',
    baseUrl: 'https://openrouter.ai/api/v1',
    defaultModel: 'meta-llama/llama-3.3-70b-instruct:free',
    models: ['deepseek/deepseek-chat', 'meta-llama/llama-3.3-70b-instruct:free'],
    apiKeyEnvVar: 'OPENROUTER_API_KEY',
  },
  {
    id: 'groq',
    name: 'Groq',
    baseUrl: 'https://api.groq.com/openai/v1',
    defaultModel: 'llama-3.3-70b-versatile',
    models: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant'],
    apiKeyEnvVar: 'GROQ_API_KEY',
  },
  {
    id: 'deepseek',
    name: 'DeepSeek',
    baseUrl: 'https://api.deepseek.com',
    defaultModel: 'deepseek-chat',
    models: ['deepseek-chat', 'deepseek-coder'],
    apiKeyEnvVar: 'DEEPSEEK_API_KEY',
  },
  {
    id: 'github',
    name: 'GitHub Models',
    baseUrl: 'https://models.inference.ai.azure.com',
    defaultModel: 'gpt-4o-mini',
    models: ['gpt-4o-mini', 'Phi-4', 'Meta-Llama-3.3-70B-Instruct'],
    apiKeyEnvVar: 'GITHUB_TOKEN',
  },
];

8.2 WinForms/.NET Implementation Guide

For developers already working in the Microsoft ecosystem, a WinForms desktop client is a natural fit. Here is a practical implementation of a multi-provider chat window.

Project setup:

<!-- .csproj — target .NET 6+ for cross-platform or .NET Framework 4.8 for legacy -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net8.0-windows</TargetFramework>
    <UseWindowsForms>true</UseWindowsForms>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
    <PackageReference Include="System.Text.Json" Version="8.0.0" />
  </ItemGroup>
</Project>

Provider client (OpenAI-compatible, works for all providers):

public class LLMClient
{
    private readonly HttpClient _http;
    private readonly string _baseUrl;
    private readonly string _model;

    public LLMClient(string baseUrl, string apiKey, string model)
    {
        _baseUrl = baseUrl;
        _model = model;
        _http = new HttpClient();
        _http.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
    }

    public async IAsyncEnumerable<string> StreamAsync(
        List<ChatMessage> messages,
        [EnumeratorCancellation] CancellationToken ct = default)
    {
        var request = new
        {
            model = _model,
            messages = messages.Select(m => new { role = m.Role, content = m.Content }),
            stream = true,
            temperature = 0.3
        };

        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        using var response = await _http.PostAsync(
            $"{_baseUrl}/chat/completions", content, ct);
        
        response.EnsureSuccessStatusCode();
        
        using var stream = await response.Content.ReadAsStreamAsync(ct);
        using var reader = new StreamReader(stream);
        
        while (!reader.EndOfStream)
        {
            var line = await reader.ReadLineAsync(ct);
            if (line?.StartsWith("data: ") != true) continue;
            var data = line[6..];
            if (data == "[DONE]") break;
            
            var chunk = JsonSerializer.Deserialize<StreamChunk>(data);
            var text = chunk?.choices?[0]?.delta?.content;
            if (text != null) yield return text;
        }
    }
}

Streaming to a RichTextBox:

private async void btnSend_Click(object sender, EventArgs e)
{
    btnSend.Enabled = false;
    _cts = new CancellationTokenSource();
    
    _messages.Add(new ChatMessage("user", txtInput.Text.Trim()));
    txtInput.Clear();
    
    var sb = new StringBuilder();
    
    try
    {
        await foreach (var token in _client.StreamAsync(_messages, _cts.Token))
        {
            sb.Append(token);
            // Update UI on UI thread
            rtbChat.Invoke(() => {
                rtbChat.AppendText(token);
                rtbChat.ScrollToCaret();
            });
        }
        _messages.Add(new ChatMessage("assistant", sb.ToString()));
    }
    catch (OperationCanceledException) { }
    finally
    {
        btnSend.Enabled = true;
    }
}

Storing API keys securely with DPAPI:

public static class SecureStorage
{
    public static void SaveKey(string providerName, string apiKey)
    {
        var bytes = Encoding.UTF8.GetBytes(apiKey);
        var encrypted = ProtectedData.Protect(bytes, null, DataProtectionScope.CurrentUser);
        var path = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
            "MultiChat", $"{providerName}.key");
        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
        File.WriteAllBytes(path, encrypted);
    }

    public static string? LoadKey(string providerName)
    {
        var path = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
            "MultiChat", $"{providerName}.key");
        if (!File.Exists(path)) return null;
        var encrypted = File.ReadAllBytes(path);
        var bytes = ProtectedData.Unprotect(encrypted, null, DataProtectionScope.CurrentUser);
        return Encoding.UTF8.GetString(bytes);
    }
}

8.3 Electron/Node.js Cross-Platform Option

For cross-platform desktop tooling (Windows + Mac + Linux), a minimal Electron app is practical. Consider also Tauri (Rust backend, web frontend) for smaller binary size.

Minimal Electron LLM client structure:

/my-llm-tool
  /main         — Electron main process
    index.js    — Window creation, IPC handlers, API calls
    providers.js — Provider config
  /renderer     — Frontend (HTML/CSS/JS or React)
    index.html
    chat.js
  package.json

Main process API handler (main/index.js):

const { ipcMain } = require('electron');
const Store = require('electron-store');

const store = new Store({ encryptionKey: 'user-specific-secret' });

ipcMain.handle('chat:stream', async (event, { providerId, messages, model }) => {
  const provider = PROVIDERS[providerId];
  const apiKey = store.get(`apiKeys.${providerId}`);
  
  const response = await fetch(`${provider.baseUrl}/chat/completions`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`,
    },
    body: JSON.stringify({ model, messages, stream: true }),
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    const text = decoder.decode(value);
    // Send chunks to renderer
    event.sender.send('chat:chunk', text);
  }
  
  event.sender.send('chat:done');
});

8.4 CLI Power Tools

For terminal-centric developers, a CLI LLM tool is often faster than a GUI. Here is a practical Node.js CLI:

Install globally:

npm install -g ai-cli-tool   # or build your own

Or build your own minimal CLI (ai.js):

#!/usr/bin/env node
const { OpenAI } = require('openai');
const readline = require('readline');

const provider = process.env.AI_PROVIDER || 'groq';
const configs = {
  groq: { baseURL: 'https://api.groq.com/openai/v1', apiKey: process.env.GROQ_API_KEY,
          model: 'llama-3.3-70b-versatile' },
  deepseek: { baseURL: 'https://api.deepseek.com', apiKey: process.env.DEEPSEEK_API_KEY,
              model: 'deepseek-chat' },
  openrouter: { baseURL: 'https://openrouter.ai/api/v1', apiKey: process.env.OPENROUTER_API_KEY,
                model: 'meta-llama/llama-3.3-70b-instruct:free' },
};

const { baseURL, apiKey, model } = configs[provider];
const client = new OpenAI({ baseURL, apiKey });

async function ask(prompt) {
  const stream = await client.chat.completions.create({
    model,
    messages: [{ role: 'user', content: prompt }],
    stream: true,
  });
  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content || '');
  }
  process.stdout.write('\n');
}

// Usage: node ai.js "your question here"
// Or: echo "your code" | node ai.js "review this"
const prompt = process.argv[2] || '';
if (process.stdin.isTTY) {
  ask(prompt);
} else {
  let stdin = '';
  process.stdin.on('data', d => stdin += d);
  process.stdin.on('end', () => ask(`${prompt}\n\n${stdin}`));
}

Shell aliases for daily use:

# Add to .bashrc or .zshrc
alias ai='node ~/tools/ai.js'
alias aig='AI_PROVIDER=groq node ~/tools/ai.js'
alias aid='AI_PROVIDER=deepseek node ~/tools/ai.js'

# Usage examples:
ai "explain closures in JavaScript"
cat myfile.py | ai "review this for bugs"
ai "React hook to debounce a value, TypeScript, code only"

8.5 Building a Local Prompt Library

A prompt library is a collection of your best prompt templates, organized by task type. Store it in a simple JSON or YAML file and load it in your desktop tool.

prompt-library.json:

{
  "prompts": [
    {
      "id": "debug-react",
      "title": "React Bug Debug",
      "tags": ["react", "debug"],
      "template": "React . Component: .\nError: \nCode:\n\nExpected: \nActual: \nFix?",
      "variables": ["version", "component", "error", "code", "expected", "actual"],
      "recommended_model": "deepseek-chat"
    },
    {
      "id": "gen-hook",
      "title": "Generate React Hook",
      "tags": ["react", "typescript", "generation"],
      "template": "React 18 + TypeScript.\nHook: (): \nBehavior: \nConstraints: \nCode only.",
      "variables": ["name", "params", "return_type", "behavior", "constraints"],
      "recommended_model": "deepseek-chat"
    },
    {
      "id": "winforms-event",
      "title": "WinForms Event Handler",
      "tags": ["winforms", "csharp"],
      "template": "WinForms . C#.\nEvent:  on \nTask: \nRequirements: \nShow complete handler.",
      "variables": ["dotnet_version", "event_name", "control", "task", "requirements"],
      "recommended_model": "gpt-4o-mini"
    }
  ]
}

In your desktop tool, render a searchable template picker. When a user selects a template, auto-fill the prompt input with the template and highlight variables for replacement. This cuts prompt writing time by 70% for recurring task types.

9. Regional Considerations and Final Thoughts

Connectivity and Latency

API providers in the US and EU add 150–300ms of network latency for users in South/Southeast Asia. This is manageable for request-response flows but noticeable in streaming UIs.

Mitigation strategies:

• Prefer Groq and Cerebras for their lower time-to-first-token despite physical distance
• For batch processing (generating documentation, batch code review), latency is irrelevant — use cheapest option
• If you are building a product for end users in India, consider hosting your backend on a cloud region close to India (AWS ap-south-1, Azure Central India) to reduce the round-trip

Payment and Billing

International credit cards and Visa/Mastercard work with all providers listed. For users without international cards:

• Groq and Google AI Studio offer free tiers requiring no payment at all
• GitHub Models requires only a GitHub account (no payment)
• Prepaid Forex cards (available at most Indian banks) work for loading credits at OpenRouter, Together AI, etc.
• UPI-to-crypto-to-USD workflows exist but are unnecessarily complex — use Forex cards instead

Data Privacy for Indian Client Work

The Digital Personal Data Protection Act 2023 (DPDP) and various client contracts may restrict sending data to foreign servers. Practical approach:

1. Code logic (no PII): Send freely to any provider
2. Database schemas with business context: Anonymize before sending
3. Customer data: Never send to third-party LLMs; use local models (Ollama + Llama on your own machine) instead
4. Client source code under NDA: Use local models or ensure your contract permits AI-assisted development

Building Your Daily Workflow

A practical daily workflow for a budget-conscious Indian developer:

Estimated monthly cost for heavy developer use: ₹200–500/month for a typical freelancer doing real project work. That is the cost of one Swiggy order, delivering roughly equivalent productivity to a ₹20,000/month premium model subscription.

Final Principle: The Minimum Viable Prompt

Every prompt you write should pass this test before you send it:

“Does every word in this prompt carry information the model needs to answer correctly?”

If the answer is no — cut. Budget models are not sensitive to social warmth. They are sensitive to precision, context, and structure. Master those three things, and the gap between a ₹500/month budget stack and a ₹20,000/month premium stack becomes, for most daily work, invisible.