Deepak Choudhary

I write system prompts, chain-of-thought (CoT) instructions, few-shot examples, and role-based contexts that get reliable, clean output from any LLM. I know how to structure prompts so the model doesn't hallucinate, stays on task, and formats output exactly as needed (JSON, markdown, structured text).

• System Prompt Design — defining model behavior, tone, constraints, and output format upfront
• Chain-of-Thought (CoT) — guiding the model to reason step-by-step before answering
• Few-Shot Prompting — giving examples inside the prompt for consistent output style
• Role Prompting — assigning personas to get domain-expert quality responses
• Instruction Tuning — iterating and testing prompts until output quality is production-grade

I integrate LLM APIs directly into web applications and scripts — not just demo projects, but production-grade integrations with proper error handling, cost awareness, and fallback logic. I've built this into Deecliq's tooling and client projects.

• OpenAI API — GPT-4o, GPT-4 Turbo via completions and chat endpoints
• Anthropic API — Claude 3.5/4, streaming responses, system messages
• Google Gemini API — multimodal input, large-context processing
• Streaming Responses — real-time token streaming to browser UI via SSE/fetch
• Rate Limiting & Retry Logic — handling 429s, exponential backoff, model fallbacks
• Token Management — estimating cost, truncating context, staying within model limits

I build automation systems where AI is one layer in a larger pipeline. The script handles data movement; the LLM handles decisions that would normally require a human. This is not "ChatGPT button" integration — it's architected workflows that run unattended.

• Data Classification — feeding hundreds of records to an LLM and getting back labelled, sorted output
• Field Extraction — pulling structured fields (name, date, amount) from unstructured text
• Content Rewriting — bulk rewriting product descriptions, error messages, or UI copy at scale
• Anomaly Flagging — using AI to spot outliers in data that rule-based checks miss
• Scheduled Pipelines — cron-triggered Python scripts that run, process, and deliver output automatically

I've built document processing pipelines for publishing and data clients that take messy, unstructured input and produce clean structured output — automatically. This includes OCR for scanned documents and AI for interpretation.

• PDF Processing — extracting text, tables, and metadata from PDFs using pdfplumber, PyMuPDF
• Tesseract OCR — running OCR on scanned images/PDFs and post-processing with AI to fix errors
• XML/HTML Parsing — parsing structured markup and using AI to interpret ambiguous or malformed content
• Summarization — condensing long documents to key points using LLMs
• Structured Extraction — getting JSON/CSV output from freeform documents (invoices, reports, articles)
• EPUB/MOBI Formatting — converting and structuring content for digital publishing workflows

AI isn't a shortcut I use carelessly — it's a precision tool. I know when to trust AI output and when to review it carefully. I use it to accelerate the mechanical parts of coding so I can focus on architecture and product decisions.

• Claude Code (Anthropic CLI) — my primary AI coding tool for complex multi-file changes and refactoring
• GitHub Copilot Pro — in-editor autocomplete, test generation, docstring writing
• ChatGPT Canvas — iterative document and code editing with inline AI feedback
• Code Review with AI — reviewing my own code for bugs, security issues, and optimization before pushing
• Debugging — pasting error stacks into Claude/ChatGPT with context and getting surgical fixes
• Proof of Output — 60+ working tools shipped on Deecliq in under 2 years, alone

I design content pipelines where AI does the heavy lifting and humans review the result — not the other way around. This means setting up the workflow so AI output is already 90% correct before a human ever looks at it.

• Blog & Article Drafts — structured outlines, first drafts, SEO-optimized versions from a brief
• Product Descriptions — bulk generation from product specs with tone and brand consistency
• UI Copy — error messages, tooltips, empty states, onboarding text — written with AI, refined by hand
• Multi-Step Pipelines — draft → review prompt → revision → format, chained in one automated flow
• Human-in-the-Loop Design — building review checkpoints so AI output doesn't go live unchecked

I build actual AI-powered products — not wrapper apps around ChatGPT, but tools where AI is one properly engineered component. Syra (Deecliq's AI chatbot) is a working example of this.

• Chat UI — message bubbles, typing indicators, auto-scroll, markdown rendering in browser
• Response Streaming — token-by-token streaming from API to browser using Server-Sent Events (SSE)
• Session Context — managing conversation history across turns, staying within token limits
• Smart Form Processors — forms that use AI to validate, interpret, and respond to user input
• AI-Powered Converters — tools that use LLMs to handle edge cases regular regex/code can't

Web scraping alone gives you messy HTML. Combining it with AI post-processing gives you clean, structured, usable data — automatically. I've built this for e-commerce, research, and publishing clients.

• requests + BeautifulSoup — scraping static pages, extracting HTML content
• Handling Dynamic Sites — understanding when to use API calls instead of scraping
• AI Post-Processing — feeding scraped text to LLMs to parse structure, fix encoding, standardize fields
• Data Deduplication — using AI to identify and merge duplicate entries rule-based logic would miss
• Bulk Output — delivering structured CSV, JSON, or XML from scraped sources at scale
• Respecting robots.txt — ethical scraping with rate limiting and proper headers

I'm Oracle-certified in database programming — which means I understand normalization, indexing, transactions, and query optimization formally. I combine that foundation with AI tools to work faster on complex queries and schema decisions.

• Schema Design — normalized relational schemas (1NF/2NF/3NF), ER diagrams, foreign keys, constraints
• SQLite — used in Deecliq's production stack; fast, portable, zero-config for web apps
• MySQL — client and freelance projects; knows InnoDB, indexing, JOINs, transactions
• Oracle DB — formal certification; PL/SQL, stored procedures, sequences, triggers
• AI-Assisted Query Writing — using Claude/ChatGPT to draft complex queries, then reviewing and optimizing them
• Query Optimization — reading EXPLAIN plans, adding indexes, rewriting slow JOINs

AI has transformed how I research. What used to take days of reading articles, comparing tools, and synthesizing findings now takes hours — with better coverage and structured output. I use this for both product decisions and client deliverables.

• Perplexity Pro — real-time web-grounded research with source citations; far better than Google for technical questions
• Claude for Synthesis — feeding large amounts of research into Claude for structured analysis and summary
• Competitor Analysis — mapping competitor features, pricing, positioning from public sources
• Technology Evaluation — researching and comparing libraries, APIs, platforms before committing to them
• Market Trends — tracking what's changing in AI/tech space and how it affects product decisions
• Structured Reports — converting research findings into clean tables, comparisons, and recommendation docs

The real power of AI isn't a single prompt — it's chaining models and scripts so each step feeds the next. I design these pipelines so the output of one AI call becomes the input to the next, with logic between them to handle errors and edge cases.

• Pipeline Architecture — designing the sequence: what runs first, what depends on what, where errors stop the chain
• Chained Prompts — output of one LLM call becomes the context for the next
• Multi-Model Routing — using fast/cheap models for simple steps, expensive models only where needed
• Zero-Touch Output — pipelines that run unattended and deliver final output (CSV, JSON, email, file) without human involvement
• Error Handling — retry logic, fallback steps, logging so failures don't silently corrupt output
• Example pipeline built: scrape 500 product pages → AI extract fields → AI classify category → clean → export CSV

I use AI image generation practically — for UI mockups, concept visuals, and brand assets that would otherwise require a dedicated designer or stock photo budget. Combined with traditional Photoshop skills, this covers the full visual production workflow.

• Midjourney — high-quality artistic and product images; knows prompt syntax (--ar, --style, --no, seeds)
• DALL-E 3 — via ChatGPT; good for specific UI concepts, diagrams, and illustrated content
• Adobe Firefly — integrated into Photoshop; Generative Fill, Remove Background, Generative Expand
• AI Upscaling — using tools like Topaz/Magnific to upscale generated images for print/high-res use
• Prompt Craft for Images — writing detailed image prompts that produce what you actually need, not random guesses
• Traditional Photoshop — combining AI generation with manual Photoshop work for final polish

The hardest skill in AI integration isn't the API calls — it's knowing where AI belongs in the product and where it doesn't. I've made enough AI decisions building Deecliq to have a clear framework for this.

• Layer Identification — breaking a workflow into: deterministic code layer, AI reasoning layer, human review layer
• Cost-Benefit Decisions — when a rule-based solution is faster and cheaper than an LLM call, use it; when it isn't, use AI
• UX for AI — designing interfaces where AI output feels helpful and trustworthy, not random
• Failure Mode Planning — every AI feature needs a graceful fallback when the model is wrong
• Model Selection — picking the right model for the task: speed, cost, context length, reasoning quality
• Avoiding AI Overuse — not using AI just because it's possible; using it where it genuinely adds value

Working in India means knowing how to build for and communicate in multiple languages. I use AI translation tools professionally — not just for translating text, but for building localized experiences that feel native.

• Hindi ↔ English — daily bilingual work; I can review AI translation quality in both languages
• Bulk Translation — feeding large batches of strings, product names, or content to AI with consistent tone instructions
• Regional Tone Adjustment — prompting models to use Indian English conventions or specific regional formality levels
• Localization Review — checking AI-translated content for cultural accuracy, not just literal correctness
• Multilingual UI — building interfaces that handle Hindi/Devanagari text correctly (font, direction, encoding)

RAG (Retrieval-Augmented Generation) is what turns a generic AI into something that actually knows your business. Instead of hoping the model guessed right, you give it the real document and let it answer from there. I've built this pattern into document tools and XML processing pipelines.

• PDF & XML chunking — splitting large documents into searchable pieces the model can work with
• Prompt injection of context — feeding the right chunk of content directly into the prompt so the model answers from your data
• AI Error Assistant pattern — parse a broken XML, feed the error + schema to the model, get a fix suggestion back
• Document Q&A — upload a file, ask a question, get a sourced answer instead of a hallucination
• Structured output extraction — using AI to pull specific fields from unstructured documents reliably

The real power of modern AI isn't the chat — it's connecting the model to tools so it can take actions. I build lightweight agent patterns where AI decides what to call, calls it, and uses the result to complete a task end-to-end.

• Function/tool calling — defining functions the AI can invoke (database lookup, API call, file read) and parsing its structured output
• API-connected agents — agents that hit external REST APIs and summarize or act on the response
• Database agents — natural language → SQL → result → AI summary; built for internal admin tools
• Multi-step reasoning — chaining multiple AI calls where each step depends on the previous result
• Human-in-the-loop — designing workflows where AI proposes, human approves, then AI continues

Shipping AI features without testing them is how you get embarrassing hallucinations in production. I test AI outputs the same way I'd test any other code — systematically, with real inputs, and with clear pass/fail criteria.

• Prompt regression testing — running the same prompts before and after changes to catch silent degradation
• Hallucination checks — comparing AI output against a known source document; flagging claims that aren't in the context
• Latency & cost monitoring — tracking token usage and response time per call to keep AI features within budget
• Output format validation — using JSON schema or regex to confirm the model returned structured output correctly
• Manual review loops — sampling AI outputs regularly and scoring them for accuracy and tone before they reach users