Claude Skills launched in October 2025 and has quietly become the most important shift in how we work with Claude. Instead of re-pasting the same instructions into every chat, you build a folder once, and Claude loads it automatically when the task calls for it. Your workflows, your style guides, and your domain expertise are embedded once and reused forever.

The problem: most of what’s written about Skills online is shallow, recycled, or outright wrong. So I went through every official Anthropic resource, every legit repo, and every credible community library to build the only list you actually need.

Here are 30 free resources, organized by what they’re actually good for.

OFFICIAL DOCS (ANTHROPIC)
↳ Agent Skills Overview: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
↳ Best Practices Guide: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices
↳ Skills API Quickstart: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/quickstart
↳ Using Skills with the API: https://platform.claude.com/docs/en/build-with-claude/skills-guide
↳ Claude API Skill Docs: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/claude-api-skill
↳ Extend Claude Code with Skills: https://code.claude.com/docs/en/skills
↳ Claude API Reference: https://platform.claude.com/docs/en/api/overview
↳ Agent SDK Docs: https://platform.claude.com/docs/en/agent-sdk/quickstart
↳ MCP Documentation: https://modelcontextprotocol.io/docs/getting-started/intro
↳ Complete Guide to Building Skills (PDF):https://resources.anthropic.com/hubfs/The-Complete-Guide-to-Building-Skill-for-Claude.pdf
↳ Anthropic Academy: https://www.anthropic.com/learn/build-with-claude

Data Science, AI & ML Mastery Pack

OFFICIAL BLOG POSTS
↳ Introducing Agent Skills: https://claude.com/blog/skills
↳ Equipping Agents with Skills (Engineering): https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
↳ Skills Explained: https://claude.com/blog/skills-explained
↳ How to Create Skills: https://claude.com/blog/how-to-create-skills-key-steps-limitations-and-examples
↳ Building Skills for Claude Code: https://claude.com/blog/building-skills-for-claude-code
↳ Frontend Design Skills: https://claude.com/blog/improving-frontend-design-through-skills

1:1 Career Development Deep Dive

OFFICIAL REPOS AND EXAMPLES
↳ anthropics/skills (Main Repo): https://github.com/anthropics/skills
↳ Skills Cookbook (Notebooks): https://github.com/anthropics/claude-cookbooks/tree/main/skills
↳ anthropics/claude-quickstarts: https://github.com/anthropics/claude-quickstarts
↳ Official Plugins Marketplace: https://github.com/anthropics/claude-plugins-official
↳ claude-api Skill (Reference): https://github.com/anthropics/skills/blob/main/skills/claude-api/SKILL.md
↳ skill-creator Skill: https://github.com/anthropics/skills/tree/main/skill-creator
↳ Document Skills (docx, pdf, pptx, xlsx): https://github.com/anthropics/skills/tree/main/document-skills
↳ Agent Skills Open Standard: https://agentskills.io

For Mock interview

COMMUNITY LIBRARIES AND DIRECTORIES
↳ skills.sh: https://skills.sh
↳ SkillsMP: https://skillsmp.com
↳ Smithery Skills: https://smithery.ai/skills
↳ SkillHub: https://skillhub.club
↳ ClaudeMarketplaces: https://claudemarketplaces.com

Save this. Share it with anyone serious about going deeper than prompts.

Subscribe now

Leave a comment

Most Claude prompt lists are padded with noise. This one is not. I went through 200 prompts, cut everything that was vague, redundant, or too niche to matter, and kept only what I would actually use in my own work. What you are left with is 100 prompts across four high-leverage areas: coding, AI systems, research, and automation.

Every prompt is a framework, not a sentence. The [BRACKETS] are where your context goes. Drop in your codebase, your use case, your product, and the prompt does the rest. Think of these as cognitive multipliers. They do not replace your judgment, they accelerate it.

How to use this: bookmark the category you need most, pick one prompt today, and use it on a real problem. That is how this list pays off.

Coding and Debugging

The prompts below turn Claude into a senior engineering co-pilot. Use them for code reviews, architectural decisions, test generation, and debugging sessions. Replace the bracketed placeholders with your actual code, error messages, or stack details.

01. Code Review

Review this code as a senior engineer. Identify bugs, security vulnerabilities, performance issues, and style problems. Explain each issue and suggest a fix: [PASTE CODE]

02. Debug This Error

I am getting this error: [ERROR MESSAGE]. Here is the relevant code: [PASTE CODE]. Walk me through every possible cause and fix each one.

03. Refactor for Readability

Refactor this code to be cleaner and more readable without changing its functionality. Add comments explaining complex logic: [PASTE CODE]

04. Write Unit Tests

Write comprehensive unit tests for this function. Cover the happy path, edge cases, null inputs, and error conditions: [PASTE FUNCTION]

05. Optimize Performance

Analyze this code for performance bottlenecks. Identify the slowest parts and rewrite them to be more efficient: [PASTE CODE]

06. Convert to TypeScript

Convert this JavaScript code to TypeScript. Add proper type definitions for all variables, parameters, and return values: [PASTE CODE]

07. Security Audit

Audit this code for security vulnerabilities. Check for SQL injection, XSS, authentication issues, exposed secrets, and any other risks: [PASTE CODE]

08. Generate API Endpoint

Write a REST API endpoint in [LANGUAGE/FRAMEWORK] that [DESCRIBE WHAT IT SHOULD DO]. Include input validation, error handling, and correct HTTP status codes.

09. Database Query Optimization

This SQL query is running slowly: [PASTE QUERY]. Analyze it, explain why it is slow, and rewrite it to be faster. Suggest any indexes that would help.

10. Design a Data Schema

Design a database schema for [DESCRIBE APPLICATION]. Include all tables, columns, data types, relationships, indexes, and explain your design decisions.

Subscribe now

11. Code Architecture Review

Review this architecture and tell me what problems you foresee at scale. What would break first and how should I redesign it: [DESCRIBE OR PASTE ARCHITECTURE]

12. Add Error Handling

Add comprehensive error handling to this code. Catch all possible failures, log them appropriately, and fail gracefully: [PASTE CODE]

13. Build an Authentication System

Design and write a JWT authentication system in [FRAMEWORK]. Include signup, login, token refresh, logout, and protected route middleware.

14. Write a CI/CD Pipeline

Write a GitHub Actions workflow that runs tests, checks code quality, builds the application, and deploys to [PLATFORM] on every push to main.

15. Build a Rate Limiter

Implement a rate limiter in [LANGUAGE] that allows [X] requests per [TIME PERIOD] per user. Handle edge cases and include a way to whitelist certain users.

16. Implement Retry Logic

Add retry logic to this function that makes an external API call. Handle rate limits, transient errors, and use exponential backoff: [PASTE FUNCTION]

17. Write Integration Tests

Write integration tests for this API endpoint that test the full request/response cycle including the database: [PASTE ENDPOINT CODE]

18. Implement Search Functionality

Implement full-text search for [DESCRIBE DATA] using [TECHNOLOGY]. Include fuzzy matching, relevance scoring, and filtering by [FIELDS].

19. Optimize a React Component

This React component is re-rendering too often and causing performance issues. Analyze it and fix the performance problems: [PASTE COMPONENT]

20. Implement Feature Flags

Design and implement a feature flag system that allows enabling or disabling features per user, per percentage of traffic, or without deploying code.

Subscribe now

21. Write a State Machine

Implement a state machine for [DESCRIBE SYSTEM WITH STATES]. Define all states, transitions, guards, and actions.

22. Build a CLI Tool

Write a command line tool in Python that [DESCRIBE FUNCTIONALITY]. Include argument parsing, error handling, help text, and a usage example.

23. Write a Health Check Endpoint

Write a health check endpoint for [FRAMEWORK] that checks database connectivity, external service availability, and system resources. Return proper HTTP status codes.

24. Write a Data Migration Script

Write a database migration script that [DESCRIBE WHAT IT NEEDS TO DO]. Make it idempotent, reversible, and safe to run on a production database.

25. Design a Microservice

Design the architecture for a microservice that handles [DESCRIBE FUNCTIONALITY]. What endpoints does it need, how does it communicate, and what is its data model?

Subscribe now

AI Workflows

These prompts are for anyone building with AI, not just using it. Design agents, evaluation frameworks, RAG pipelines, multi-agent systems, and more. Treat these as system design sessions where Claude is the architect.

26. Design an AI Agent

Design an AI agent that can [DESCRIBE GOAL]. What tools does it need, what decisions should it make autonomously, what should require human approval, and how should it handle failures?

27. Build a Prompt Chain

Design a multi-step prompt chain that takes [INPUT] and produces [OUTPUT]. Break it into discrete steps, define what each step does, and explain how outputs feed into the next step.

28. Create a System Prompt

Write a system prompt for an AI assistant that works as a [DESCRIBE ROLE] for [DESCRIBE COMPANY/USE CASE]. Define its personality, capabilities, limitations, and how it should handle edge cases.

29. Evaluate Prompt Quality

Evaluate this prompt and tell me everything that is wrong with it. Then rewrite it to be more precise, consistent, and likely to produce the output I actually want: [PASTE PROMPT]

30. Design a RAG System

Design a Retrieval Augmented Generation system for [DESCRIBE USE CASE]. What data should be indexed, how should it be chunked, what embedding model should be used, and how should retrieval work?

31. Create an Extraction Prompt

Write a prompt that extracts [DESCRIBE INFORMATION] from [DESCRIBE DOCUMENT TYPE]. Output as structured JSON. Handle missing fields gracefully and flag uncertain extractions.

32. Design a Multi-Agent System

Design a multi-agent system where [NUMBER] AI agents collaborate to accomplish [DESCRIBE GOAL]. Define each agent’s role, how they communicate, and how conflicts are resolved.

33. Build an AI Evaluation Framework

Design a framework for evaluating the quality of AI outputs for [DESCRIBE USE CASE]. What metrics matter, how should they be measured, and what does good versus bad look like?

34. Build a Question Answering System

Design a question answering system over [DESCRIBE KNOWLEDGE BASE]. How should documents be preprocessed, what retrieval strategy works best, and how should confidence be communicated to users?

35. Create a Data Enrichment Workflow

Design a workflow that takes [DESCRIBE INPUT DATA] and enriches it with [DESCRIBE ADDITIONAL INFORMATION] using AI. Define the steps, prompts, and how to handle failures.

Subscribe now

36. Build a Feedback Loop System

Design a system where AI outputs are evaluated, feedback is collected, and the system improves over time for [DESCRIBE USE CASE]. How is quality measured and what triggers retraining?

37. Document Processing Pipeline

Design a pipeline that ingests [DESCRIBE DOCUMENT TYPES], extracts structured data, validates it, and stores it in [DESCRIBE SYSTEM]. Handle OCR, various formats, and malformed inputs.

38. Build a Monitoring System for AI

Design a monitoring system for an AI pipeline that tracks output quality, latency, cost, and failure rates. What alerts should exist and what dashboards need to be built?

39. Create a Prompt Template Library

Create a library of 10 reusable prompt templates for [DESCRIBE USE CASE]. Each template should have placeholders, usage instructions, and example inputs and outputs.

40. Design a Human-in-the-Loop System

Design a system where AI handles [DESCRIBE TASKS] autonomously but routes edge cases to humans. Define the confidence thresholds, escalation paths, and how human feedback is incorporated.

41. Create AI Customer Service Agent

Design an AI customer service agent for [DESCRIBE BUSINESS]. What questions can it answer, when should it escalate to a human, and how should it handle frustrated customers?

42. Design a Code Review AI

Design an AI code review system that automatically reviews pull requests for [DESCRIBE STANDARDS]. What should it check, and how should feedback be formatted to be actionable?

43. Build a Research Assistant

Design an AI research assistant that can [DESCRIBE RESEARCH TASKS]. How should it search, synthesize information, cite sources, and flag low-confidence conclusions?

44. Design a Meeting Intelligence System

Design an AI system that processes meeting transcripts and produces [DESCRIBE OUTPUTS: action items, summaries, decisions]. How should it handle multiple speakers and task assignments?

45. Build a Contract Analysis Pipeline

Design an AI pipeline that analyzes contracts and flags [DESCRIBE RISK TYPES]. What clauses should trigger alerts, how should confidence be communicated, and when should a lawyer review?

Access AI Books Here

46. Create a Sentiment Analysis System

Design a sentiment analysis system for [DESCRIBE DATA SOURCE]. What dimensions of sentiment matter, how should nuance be handled, and how should results be aggregated for reporting?

47. Content Recommendation Engine

Design a content recommendation engine for [DESCRIBE PLATFORM]. What signals drive recommendations, how should diversity be maintained, and how should new content be handled?

48. Anomaly Detection System

Design an AI anomaly detection system for [DESCRIBE DATA]. What constitutes an anomaly, how should severity be classified, and what should happen when one is detected?

49. Build a Trend Detection System

Design an AI system that monitors [DESCRIBE DATA SOURCES] and identifies emerging trends in [DESCRIBE DOMAIN]. How should trends be validated and false positives filtered?

50. Design a Voice AI System

Design a voice AI assistant for [DESCRIBE USE CASE]. How should speech be processed, what intents need to be recognized, and how should ambiguous requests be handled?

Access AI Books & Notes Here

Research and Analysis

These prompts structure your thinking. Use them for market research, investment analysis, competitive intelligence, and any situation where you need to go deeper than a surface-level answer. They are frameworks, not searches.

51. Deep Research Brief

Research [TOPIC] comprehensively. Cover the current state, key players, recent developments, open questions, and what experts disagree about. Structure as a research brief.

52. Competitive Analysis

Analyze [COMPANY/PRODUCT] against its top 5 competitors. Compare on [DIMENSIONS]. Identify where it leads, where it lags, and where the biggest opportunities are.

53. Market Size Estimation

Estimate the market size for [DESCRIBE MARKET]. Use a bottom-up approach, show your assumptions clearly, and give a range rather than a single number.

54. Argument Steel-Manning

Steel-man the argument that [CONTROVERSIAL POSITION]. Present the strongest possible version of this argument as its best advocate would make it. Then identify its weakest points.

55. Investment Thesis Analysis

Analyze the investment thesis for [COMPANY/ASSET]. What has to be true for this to be a good investment, what are the key risks, and what would change your view?

56. SWOT Analysis

Conduct a deep SWOT analysis for [COMPANY/PROJECT/IDEA]. Go beyond surface-level observations and identify second-order implications of each factor.

57. First Principles Analysis

Analyze [PROBLEM/INDUSTRY/ASSUMPTION] from first principles. What are the irreducible truths, what assumptions are people making that might be wrong, and what does this suggest?

58. Historical Pattern Analysis

Analyze historical examples of [DESCRIBE SITUATION OR PATTERN]. What patterns emerge, what caused success or failure, and what lessons apply to [CURRENT SITUATION]?

59. Risk Analysis

Conduct a comprehensive risk analysis for [DESCRIBE PROJECT OR DECISION]. Identify all risks, assess likelihood and impact, prioritize them, and suggest mitigations for the top five.

60. Scenario Planning

Develop three scenarios for [DESCRIBE SITUATION]: a base case, an optimistic case, and a pessimistic case. What would cause each to occur and how should we prepare for each?

61. Causal Chain Analysis

Map the causal chain from [ROOT CAUSE] to [OUTCOME]. What are all the links in the chain, where could intervention have the most impact, and what feedback loops exist?

62. Trend Analysis

Analyze the trend of [DESCRIBE TREND]. How long has it been building, what is driving it, how durable is it, and what are its second and third-order effects?

63. Decision Framework

Build a decision framework for [DESCRIBE DECISION TYPE]. What factors matter, how should they be weighted, what information is needed, and what does a good decision process look like?

64. Root Cause Analysis

Conduct a root cause analysis of [DESCRIBE PROBLEM OR FAILURE]. Use the five whys method, identify contributing factors, and recommend actions that address root causes, not symptoms.

65. Stakeholder Analysis

Map the stakeholders for [DESCRIBE PROJECT OR DECISION]. Who has power, who is affected, what does each party want, and how should each be engaged?

Subscribe now

66. Hypothesis Generation

Generate 10 testable hypotheses about [DESCRIBE PHENOMENON OR PROBLEM]. For each, describe what evidence would confirm or refute it and how it could be tested.

67. Assumption Mapping

Map all the assumptions underlying [DESCRIBE PLAN OR BELIEF]. Categorize them by how critical they are and how uncertain they are. Which assumptions most need to be tested first?

68. Second-Order Effects

Analyze the second and third-order effects of [DESCRIBE DECISION OR TREND]. Go beyond the obvious first-order effects and identify what most people are missing.

69. Pre-Mortem Analysis

Conduct a pre-mortem for [DESCRIBE PLAN]. Imagine it is 12 months from now and this has failed. What went wrong, why did it fail, and what could have been done differently?

70. Value Chain Analysis

Map the value chain for [DESCRIBE INDUSTRY]. Where is value created, where is it captured, where are the margins, and where is disruption most likely to occur?

71. Network Effects Analysis

Analyze the network effects dynamics in [DESCRIBE MARKET OR PRODUCT]. What type of network effects exist, how strong are they, and what does this mean for competitive dynamics?

72. Jobs to Be Done Analysis

Apply the Jobs to Be Done framework to understand why customers hire [DESCRIBE PRODUCT OR SERVICE]. What functional, emotional, and social jobs is it doing?

73. Moat Analysis

Analyze the competitive moat of [COMPANY]. What sustainable advantages does it have, how durable are they, and what would erode them over the next five years?

74. Supply and Demand Analysis

Analyze the supply and demand dynamics for [DESCRIBE MARKET]. What drives demand, what constrains supply, how tight is the market, and what would shift the balance?

75. Go-to-Market Analysis

Analyze the go-to-market strategy for [DESCRIBE PRODUCT]. Who is the beachhead customer, what is the sales motion, how does word of mouth work, and what drives viral growth?

Access AI Books & PDFs here

Automation

Use these prompts to design end-to-end automation systems. They are strong for Zapier workflows, data pipelines, onboarding flows, CRM automations, and anything that runs without you. Tell Claude what you are automating and let it map the entire system.

76. Map a Manual Process

I do this task manually: [DESCRIBE TASK]. Map every step in detail, identify which steps could be automated, and design an automation that handles the full workflow.

77. Zapier Workflow Design

Design a Zapier workflow that automates [DESCRIBE PROCESS]. Define the trigger, all the steps in sequence, what data is passed between steps, and how errors are handled.

78. Email Automation Sequence

Design an automated email sequence for [DESCRIBE PURPOSE]. Write the copy for each email, define the triggers and timing, and explain the goal of each message.

79. Build a Data Pipeline

Design a data pipeline that takes [DESCRIBE INPUT], transforms it by [DESCRIBE TRANSFORMATIONS], and loads it into [DESCRIBE DESTINATION]. Include error handling and monitoring.

80. Automate Report Generation

Design an automation that pulls data from [DESCRIBE SOURCES], calculates [DESCRIBE METRICS], generates a [FORMAT] report, and sends it to [RECIPIENTS] every [FREQUENCY].

Subscribe now

81. Build a Lead Qualification Bot

Design an automated lead qualification system that [DESCRIBE HOW LEADS COME IN], asks qualifying questions, scores them against [DESCRIBE CRITERIA], and routes them to the right person.

82. Customer Onboarding Automation

Design an automated customer onboarding flow for [DESCRIBE PRODUCT]. What happens at each step, what triggers the next step, and how are stuck customers identified and helped?

83. Build a Monitoring Alert System

Design an automated monitoring system for [DESCRIBE WHAT IS BEING MONITORED]. What metrics trigger alerts, how are alerts prioritized, and what information is included in each alert?

84. Automate Customer Support Triage

Design an automation that receives support requests, categorizes them by type and priority, routes them to the right team, and sends an acknowledgment to the customer.

85. Content Publishing Pipeline

Design an automated content publishing pipeline that takes a draft, runs it through [DESCRIBE CHECKS], formats it for [PLATFORMS], schedules publication, and tracks distribution.

86. Automate Competitive Monitoring

Design an automation that monitors [DESCRIBE COMPETITORS] for changes to [DESCRIBE WHAT TO MONITOR] and delivers a weekly digest with the most important changes highlighted.

87. Build a CRM Automation

Design automations for [CRM SYSTEM] that handle [DESCRIBE SCENARIOS]. What triggers each automation, what actions does it take, and how does it update records?

88. Automate Employee Onboarding

Design an automated employee onboarding workflow that handles account creation, equipment provisioning, training assignments, introduction emails, and day-one check-ins.

89. Automate Meeting Follow-Ups

Design an automation that processes meeting transcripts, extracts action items, assigns them to owners, creates tasks in [PROJECT MANAGEMENT TOOL], and sends follow-up emails.

90. Build a Price Monitoring System

Design an automation that monitors competitor prices for [DESCRIBE PRODUCTS] across [CHANNELS], alerts when significant changes occur, and provides pricing recommendations.

91. Automate Job Posting and Screening

Design an automation for the recruitment process that posts jobs, screens applications against [CRITERIA], schedules interviews for qualified candidates, and sends rejections.

92. Automate Customer Win-Back

Design an automated win-back campaign for churned customers. What triggers it, what is the sequence of messages, what offers are made, and when does it stop?

93. Automate Sales Forecasting

Design an automation that pulls data from [CRM AND OTHER SOURCES], applies [DESCRIBE FORECASTING MODEL], generates weekly forecast reports, and flags deals needing attention.

94. Automate IT Ticket Routing

Design an automation that receives IT support tickets, categorizes them, assigns priority, routes to the right team, and tracks resolution time against SLAs.

95. Build an A/B Testing Automation

Design a system that sets up A/B tests for [DESCRIBE WHAT IS BEING TESTED], monitors results, determines statistical significance, implements winners, and documents learnings.

96. Build a User Lifecycle Automation

Design automated workflows for each stage of the user lifecycle for [DESCRIBE PRODUCT]: activation, engagement, retention, re-engagement, and win-back.

97. Automate Customer Health Scoring

Design an automation that monitors [DESCRIBE CUSTOMER SIGNALS], calculates health scores, segments customers by risk, and triggers appropriate outreach for at-risk accounts.

98. Build a Security Scanning Pipeline

Design an automated security scanning pipeline for [DESCRIBE WHAT IS BEING SCANNED]. What tools run, what findings are critical versus informational, and how are remediations tracked?

99. Build a Release Management Pipeline

Design an automated release management process for [DESCRIBE APPLICATION]. How are releases staged, tested, approved, deployed, and monitored after going live?

100. Automate Financial Reconciliation

Design an automation that reconciles [DESCRIBE ACCOUNTS] by matching transactions, flagging discrepancies, generating exception reports, and updating records after review.

Data Science, AI & ML Mastery Pack

Most people treat Claude like a $20 search engine. They type a question. They get an answer. They move on.

They do not realize Claude can function as a full development team: architect, reviewer, debugger, technical writer, all working together. They simply do not know skills exist.

The difference comes down to skills. 50 of them below, every install command included, organized by use case.

What a Claude skill actually is

A skill is nothing more than a folder containing a SKILL.md file. Inside that file you define a process, rules to follow, sample outputs, and sometimes scripts or templates Claude can run.

The point is that you stop repeating yourself. Explain a workflow once, package it as a skill, and every future session inherits it automatically.

Installs follow this pattern:

npx skills@latest add mattpocock/skills/[skill-name]

Where to find them:

• Anthropic’s official collection: github.com/anthropics/skills

• Matt Pocock’s personal repo (15k stars): github.com/mattpocock/skills

• The community index (66k+ skills): skillsmp.com

Skills for managing your own skill library

This first group exists to help you create, test, and organize everything else on this list.

Skill Creator

Function: Runs Claude against your actual task, observes the results, and uses that data to help you write a working skill. Best used when you have a messy process and want it turned into a clean SKILL.md.

Repo: github.com/anthropics/skills/tree/main/skills/skill-creator

Process: Outline your workflow as bullets. Have Skill Creator draft an initial version. Test it against 3 to 5 real prompts, note what breaks, and refine from there.

Write a Skill

Function: Walks Claude through proper skill architecture, structure, progressive disclosure, and any bundled files needed. This is how you build skills that hold up over time instead of degrading.

Repo: github.com/mattpocock/skills/tree/main/write-a-skill

Install:

npx skills@latest add mattpocock/skills/write-a-skill

Use this right after Skill Creator hands you a rough draft that needs proper structuring.

Find Skills

Function: Searches community marketplaces such as SkillsMP for something matching what you need.

Marketplace: skillsmp.com

Rule of thumb: treat skill discovery like dependency management. Search before you write something from scratch, because chances are someone already built it.

Skills for planning and design work

These exist specifically to stop you from shipping the wrong thing.

Grill Me

Function: Pushes Claude to interrogate your feature idea, asking one pointed question after another until every edge case and decision point is accounted for.

Best for: New builds, major refactors, anything risky.

Install:

npx skills@latest add mattpocock/skills/grill-me

Repo: github.com/mattpocock/skills/tree/main/grill-me

Expect questions about data structures, failure scenarios, and how this touches existing systems. Better to answer them now than debug them later.

Write a PRD

Function: Walks you through an interview, explores your codebase, designs the relevant modules, and produces a PRD filed directly as a GitHub issue.

Install:

npx skills@latest add mattpocock/skills/write-a-prd

Repo: github.com/mattpocock/skills/tree/main/write-a-prd

Direct it to:

• Define goals and explicit non-goals

• List success metrics and constraints

• Map connections to systems you will be touching

PRD to Plan

Function: Converts a finished PRD into a staged implementation plan built around tracer-bullet vertical slices. This is not a simple task list, it is a sequencing strategy designed to reduce integration risk.

Install:

npx skills@latest add mattpocock/skills/prd-to-plan

Repo: github.com/mattpocock/skills/tree/main/prd-to-plan

Distinction from PRD to Issues: a plan gives you order and stages, issues give you independence. You will likely want both.

PRD to Issues

Function: Splits a PRD into standalone GitHub issues, each a vertical slice, with dependencies between them clearly marked.

Install:

npx skills@latest add mattpocock/skills/prd-to-issues

Repo: github.com/mattpocock/skills/tree/main/prd-to-issues

Sample instruction:

“Apply PRD to Issues on the document above. Group the resulting issues by epic and state any blockers explicitly.”

Design an Interface

Purpose: Produces several genuinely different interface concepts for a module by running parallel sub-agents.

Install:

npx skills@latest add mattpocock/skills/design-an-interface

Repo: github.com/mattpocock/skills/tree/main/design-an-interface

Instead of one option, you get 3 to 5 with distinct tradeoffs. Choose based on your actual constraints.

Request Refactor Plan

Function: Interviews you about the refactor, then produces a step-by-step plan broken into small commits, filed as a GitHub issue.

Install:

npx skills@latest add mattpocock/skills/request-refactor-plan

Repo: github.com/mattpocock/skills/tree/main/request-refactor-plan

Skills for active development

This group converts Claude from an autocomplete tool into something closer to a careful engineering partner.

TDD

Function: Enforces a strict red-green-refactor cycle. Tests come first, always.

Install:

npx skills@latest add mattpocock/skills/tdd

Repo: github.com/mattpocock/skills/tree/main/tdd

Process:

1. Write the failing test

2. Write just enough code to pass it

3. Refactor while the tests still hold

Triage Issue

Function: Digs through the codebase to locate the actual cause of a bug, then files a GitHub issue with a TDD-driven fix plan attached.

Install:

npx skills@latest add mattpocock/skills/triage-issue

Repo: github.com/mattpocock/skills/tree/main/triage-issue

This is your “I genuinely do not know what is broken” tool. It investigates first, then hands you a clear plan.

QA

Function: Performs a complete QA sweep on a feature, surfacing issues with explicit blocking relationships between them.

Install:

npx skills@latest add mattpocock/skills/qa

Repo: github.com/mattpocock/skills/tree/main/qa

Run before merging:

• Catch edge cases

• Get issues filed in the right order

• Ship without breaking things downstream

Improve Codebase Architecture

Function: Audits your codebase for structural weaknesses, with particular focus on modules that are too shallow and code that is hard to test.

Install:

npx skills@latest add mattpocock/skills/improve-codebase-architecture

Repo: github.com/mattpocock/skills/tree/main/improve-codebase-architecture

Ask for:

• Identified problem areas

• 2 to 3 possible refactor approaches

• A breakdown of risk, effort, and payoff for each

Auto-Commit Messages

Function: Reads your staged changes and writes a proper conventional commit, type, scope, and description included.

Install:

npx skills@latest add anthropics/skills/auto-commit

Repo: github.com/anthropics/skills/tree/main/skills/auto-commit

Useful when you are done typing “fix stuff” as a commit message.

Code Review

Function: Delivers a structured review covering security gaps, performance issues, error handling, and architectural concerns.

Repo: github.com/anthropics/skills (search Code Review)

Request options: “Security-first review.” “Performance-first review.” Or a complete checklist run.

Systematic Debugging

Source: Part of the Superpowers repo.

Function: A disciplined four-stage debugging process that explicitly bans random trial-and-error edits.

Repo: github.com/obra/superpowers/tree/main/skills/systematic-debugging

Steps:

1. Reproduce the bug with the smallest possible failing test

2. Isolate the actual cause

3. Make one targeted fix

4. Confirm with both tests and logs

Brainstorming

Function: Develops a raw idea into a full flow and architecture using Socratic-style questioning.

Best used before writing any code for data modeling, API design, and thinking through failure recovery.

Repo: github.com/obra/superpowers/tree/main/skills/brainstorming

Superpowers

Description: A complete collection of proven skills covering testing, debugging, refactoring, and execution.

Repo: github.com/obra/superpowers

Treat it as your baseline engineering layer.

React Best Practices

Function: Applies Vercel and Next.js conventions to your React codebase.

Use case: Migrating to Next.js, cleaning up legacy React, or onboarding junior engineers.

Repo: github.com/vercel-labs/agent-skills/tree/main/skills/react-best-practices

File Search

Function: Equips Claude with ripgrep and ast-grep so it can navigate large codebases efficiently.

Repo: github.com/massgen/massgen

Context Optimization

Function: Shrinks context size and reduces token spend while preserving what actually matters.

Repo: github.com/muratcankoylan/agent-skills-for-context-engineering

Skills for setup and tooling

This category covers things you configure once and never think about again.

Setup Pre-Commit

Function: Configures Husky pre-commit hooks alongside lint-staged, Prettier, type checks, and test runs.

Install:

npx skills@latest add mattpocock/skills/setup-pre-commit

Repo: github.com/mattpocock/skills/tree/main/setup-pre-commit

Apply this to every new repo you start. You will be glad you did.

Git Guardrails for Claude Code

Function: Installs hooks that intercept and block destructive git commands such as push, reset --hard, and clean before they run.

Install:

npx skills@latest add mattpocock/skills/git-guardrails-claude-code

Repo: github.com/mattpocock/skills/tree/main/git-guardrails-claude-code

Mandatory if you are running Claude Code against production. Speed is great until something irreversible happens. This is your safeguard.

Dependency Auditor

Function: Scans package.json for outdated, vulnerable, or abandoned dependencies and ranks fixes by priority.

Use case: Old repos you are afraid to touch with a regular audit command.

Install:

npx skills@latest add ComposioHQ/awesome-claude-skills/dependency-auditor

Repo: github.com/ComposioHQ/awesome-claude-skills

Git Work Trees

Function: Handles isolated branch-based development without disrupting your primary codebase.

Use case: Running experimental work or multiple features in parallel.

Skills for issue and project tracking

GitHub Triage

Function: Sorts incoming GitHub issues using a defined brief that tells Claude exactly what falls in scope and what does not.

Install:

npx skills@latest add mattpocock/skills/github-triage

Repo: github.com/mattpocock/skills/tree/main/github-triage

Use it to:

• Clear large issue backlogs quickly

• Auto-label and categorize

• Route each issue to the right owner or epic

Skills for writing and documentation

Edit Article

Function: Reworks articles by reorganizing structure, sharpening clarity, and trimming unnecessary words.

Install:

npx skills@latest add mattpocock/skills/edit-article

Repo: github.com/mattpocock/skills/tree/main/edit-article

This goes beyond grammar fixes. It restructures the actual argument and sharpens each section’s point.

Ubiquitous Language

Function: Pulls a DDD-style glossary of terms straight from your conversation history.

Install:

npx skills@latest add mattpocock/skills/ubiquitous-language

Repo: github.com/mattpocock/skills/tree/main/ubiquitous-language

The value:

• Teams accumulate private jargon

• “Event,” “order,” and “user” mean different things depending on who is talking

• This skill forces those definitions into the open before any code gets written

API Documentation Generator

Function: Examines your routes and produces OpenAPI/Swagger documentation, including examples, error codes, and auth details.

Use case: You shipped the API and forgot the docs entirely.

Install:

npx skills@latest add ComposioHQ/awesome-claude-skills/api-docs-generator

Repo: github.com/ComposioHQ/awesome-claude-skills

Content Researcher

Function: Studies your writing patterns and produces long-form content, blogs and newsletters, backed by real citations.

Use case: Translating your Twitter voice into longer formats, or producing SEO-driven posts.

Repo: github.com/ComposioHQ/awesome-claude-skills/blob/master/content-research-writer/SKILL.md

Obsidian Vault

Function: Navigates, creates, and links notes inside an Obsidian vault.

Install:

npx skills@latest add mattpocock/skills/obsidian-vault

Repo: github.com/mattpocock/skills/tree/main/obsidian-vault

Skills for UI and frontend design

Frontend Design

Function: Directs Claude toward clean, contemporary interface output.

Repo: github.com/anthropics/skills/tree/main/skills/frontend-design

Theme Factory

Function: Builds an entire color system and theme from a short text description.

Repo: github.com/anthropics/skills/tree/main/skills/theme-factory

Flow:

1. Describe the brand feel (”calm fintech, trust, dark accent”)

2. Receive a token-based palette

3. Drop it into Tailwind or CSS variables

Canvas Design

Function: Converts text descriptions into social graphics, posters, and cover images.

Repo: github.com/anthropics/skills/tree/main/skills/canvas-design

Web Artifacts Builder

Function: Constructs interactive dashboards, calculators, and small tools from plain language requests.

Repo: github.com/anthropics/skills/tree/main/skills/web-artifacts-builder

Brand Guidelines

Function: Keeps every new component consistent with your established brand system.

Repo: github.com/anthropics/skills/tree/main/skills/brand-guidelines

Skills for business and marketing

Domain Name Brainstormer

Function: Suggests product names and checks whether the domains are actually available.

Use case: Launching a new product or sub-brand.

Repo: github.com/Microck/ordinary-claude-skills/tree/main/skills_all/domain-name-brainstormer

Stripe Integration

Function: Builds out payment flows, webhooks, and subscription logic the right way, avoiding common API pitfalls.

Repo: github.com/wshobson/agents/tree/main/plugins/payment-processing/skills/stripe-integration

Lead Research Assistant

Function: Identifies target companies and the relevant decision-makers based on your ideal customer profile.

Use case: Building B2B outreach lists, scouting partnerships.

Repo: github.com/ComposioHQ/awesome-claude-skills/blob/master/lead-research-assistant/SKILL.md

Marketing Skills

Description: A bundle of 20+ skills covering conversion optimization, copywriting, and email sequences.

Repo: github.com/coreyhaines31/marketingskills

Claude SEO

Function: Runs a complete technical SEO audit, including schema markup and on-page optimization.

Repo: github.com/AgriciDaniel/claude-seo

Skills for media generation

Image Generator

Function: Connects to external image APIs like Nano Banana Pro for photorealistic output.

• Nano Banana Pro: github.com/feedtailor/ccskill-nanobanana

• Nano Banana 2: github.com/kingbootoshi/nano-banana-2-skill

Image Optimizer

Function: Converts and resizes images into WebP format for faster page loads.

Repo: mcpmarket.com/tools/skills/image-optimizer

Remotion Best Practices

Function: Bakes in proven patterns for generating video and motion graphics through Remotion.

Repo: github.com/remotion-dev/remotion

Skills for documents and office work

PDF Processing

Function: Pulls tables out of PDFs, fills out forms, and merges multiple files together.

Repo: github.com/anthropics/skills/tree/main/skills/pdf

DOCX

Function: Modifies Word documents while preserving tracked changes and formatting.

Repo: github.com/anthropics/skills/tree/main/skills/docx

PPTX

Function: Builds and edits slide decks, layouts, speaker notes, the works.

Repo: github.com/anthropics/skills/tree/main/skills/pptx

XLSX

Function: Generates formulas, pivot tables, and charts from plain-language instructions.

Repo: github.com/anthropics/skills/tree/main/skills/xlsx

Excel MCP Server

Function: Edits Excel files directly through MCP, no desktop application required.

Repo: github.com/haris-musa/excel-mcp-server

GWS (Google Workspace)

Function: Automates Calendar, Drive, and Docs actions.

Use cases: Rescheduling meetings, organizing shared drives, generating documents from templates.

Repo: github.com/googleworkspace/cli

Skills for multi-agent work and browsing

Stochastic Multi-Agent Consensus

Function: Deploys multiple sub-agents on the same problem, then aggregates their conclusions.

Use case: Major strategic calls, architecture decisions, risk evaluation.

Repo: github.com/hungv47/meta-skills

Playwright CLI

Function: Operates an actual browser through Playwright for regression testing and walking through user funnels.

Repo: github.com/microsoft/playwright

Firecrawl Skill

Function: Pulls structured data from sites that resist standard scraping methods.

Repo: github.com/mendableai/firecrawl

Putting it all together

Begin with the workspace skills. Get Write a Skill and Skill Creator installed so you can build and maintain skills correctly from the start.

Layer in planning skills next: Grill Me, Write a PRD, PRD to Plan, PRD to Issues, Design an Interface. These alone eliminate most rework.

Lock down safety on the engineering side: Git Guardrails, Setup Pre-Commit, TDD, Systematic Debugging, Triage Issue. Standard on every repository.

Add Superpowers as your foundational engineering layer: github.com/obra/superpowers

Stack business-focused skills on top: Marketing Skills, Claude SEO, Lead Research, Content Researcher.

Use SkillsMP whenever there is a gap: skillsmp.com. Search before building something new.

Leave a comment

Here’s the thing nobody tells you: the model isn’t the bottleneck. What makes AI-built sites look “AI-built” is that they’re missing two ingredients: a real design system, and real footage. Give Claude those, and the output just looks like a studio made it.

Here’s the whole flow:

1. Get Claude Desktop (Download Claude here). The Code tab can actually write, preview, and iterate on real project files; that’s your build engine.

2. Borrow a world-class design system. (https://refero.design/)Head to styles. refero.design, a library of thousands of beautifully designed sites, each with a Design.md file you can copy. That one file encodes the entire visual language: typography, color palette, spacing rhythm, and motion style. It’s basically a professional designer’s brain, exported as text.

3. Prompt Claude with it. In the Code tab, write one line about what you’re building, something like “Check the attached design file and build the website,” then paste the design.md code underneath. Claude builds the whole site to match that system. One line plus one file, that’s the entire prompt.

4. Make a hero video (this is the part that changes everything). Go to higgsfield.ai, generate an image first, then switch to video mode, pick Kling 3.0, attach your image, and add a simple motion prompt, something like “the camera stays stationary, the character’s scarf flows in the wind, and grass blows gently.” Download the clip. {You can skip this part if you want static site.}

5. Hand it to Claude. Attach the video and just say “use this as the hero.” Claude wires it in.

And that’s it, a site with a real design language and real cinematic motion, built faster than it takes to brief a freelancer.

You’ve trained a model. Accuracy looks good. You save it. And then… nothing.

The notebook sits there. Nobody else can use it. The model never leaves your laptop.

Under 50 lines of Python. A trained scikit-learn model, a FastAPI server, a Dockerfile, a Python client, and a requirements file. That’s the whole thing.

What’s inside the box

Clone it and you get a directory that looks like this:

The model is a pre-trained classifier on the classic Iris dataset, saved with joblib. The server is a FastAPI app that loads the model at startup and exposes a single POST /predict endpoint. The Dockerfile packages it all into a portable, reproducible container. Let’s go layer by layer.

The system at a glance

server.py - deceptively simple

Here is the entire server, annotated:

from fastapi import FastAPI
import joblib
import numpy as np

# Model loaded ONCE at import time — no per-request overhead
model = joblib.load(’app/model.joblib’)

# Map integer predictions back to human-readable labels
class_names = np.array([’setosa’, ‘versicolor’, ‘virginica’])

app = FastAPI()

@app.get(’/’)
def read_root():
    return {’message’: ‘Iris model API’}

@app.post(’/predict’)
def predict(data: dict):
    “”“
    Accepts: {”features”: [5.1, 3.5, 1.4, 0.2]}
    Returns: {”predicted_class”: “setosa”}
    “”“
    features = np.array(data[’features’]).reshape(1, -1)
    prediction = model.predict(features)
    class_name = class_names[prediction][0]
    return {’predicted_class’: class_name}

Three patterns worth noting here:

1. Global model loading

The joblib.load() call happens at module import time — not inside the endpoint function. This means deserialization cost is paid once when the container starts, not on every request. For larger models, this is critical.

2. Untyped dict body

The request body is typed as a plain dict. It works, but a Pydantic model would give you automatic validation and a nicer OpenAPI schema — a natural next step when adapting this template.

3. Auto-generated docs

Because FastAPI is used, you get a Swagger UI at /docs for free. Zero extra code needed — just open the browser and test your endpoint interactively.

Dockerfile - what each line actually does

# Start from official Python 3.11 base — slim might be better for prod
FROM python:3.11

# All commands run from /code inside the container
WORKDIR /code

# Copy deps first — Docker caches this layer if requirements.txt unchanged
COPY ./requirements.txt /code/requirements.txt
RUN pip install --no-cache-dir -r /code/requirements.txt

# Copy the app directory (model + server)
COPY ./app /code/app

# Document the port (doesn’t actually publish it — that’s -p at runtime)
EXPOSE 8000

# Start Uvicorn serving the FastAPI app on all interfaces
CMD [”uvicorn”, “app.server:app”, “--host”, “0.0.0.0”, “--port”, “8000”]

Three commands from zero to inference

1. Build the image

Docker reads the Dockerfile, pulls the Python base, installs deps, and bakes the model in.

docker build -t iris-api

2. Run the container

Map your host port 8000 to the container’s 8000. Uvicorn starts automatically.

docker run --name iris-container -p 8000:8000 iris-api

3. Hit the endpoint

Send four Iris features (sepal length, sepal width, petal length, petal width). Get a class back.

curl -X POST “http://0.0.0.0:8000/predict” \
  -H “Content-Type: application/json” \
  -d ‘{”features”: [5.1, 3.5, 1.4, 0.2]}’

# Response:
{”predicted_class”: “setosa”}

The Python client - because curl gets old fast

The repo includes client.py - a script that loops over a batch of 12 flower measurements and collects predictions:

import json, requests

data = [[4.3, 3.0, 1.1, 0.1], [5.8, 4.0, 1.2, 0.2], ...]
url  = ‘http://0.0.0.0:8000/predict/’

predictions = []
for record in data:
    resp = requests.post(url, data=json.dumps({’features’: record}))
    predictions.append(resp.json()[’predicted_class’])

print(predictions)
# [’setosa’, ‘setosa’, ‘setosa’, ...]

Why this template matters

The ML community has a deployment gap problem. Models get trained, celebrated, and shelved. This repo offers a concrete, working pattern that you can clone, swap in your own model.joblib, and have a running API in minutes.

The technology choices (FastAPI over Flask, Uvicorn, joblib, Docker) are all industry-standard. The file count is ruthlessly small. There’s nothing to get lost in.

If you’re an ML practitioner who has never deployed a model, this is your entry point. If you’re an experienced engineer, it’s a clean boilerplate to modify rather than build from scratch.

Access the whole GitHub repo here:

https://github.com/DanilZherebtsov/ml-docker-flask-api.git

Share Growtechie

Most people use Claude Code like a smart assistant.

Prompt.
Wait.
Review.
Prompt again.

Over and over.

But there’s another way to use it, where Claude keeps working on it on its own until the task is actually finished.

That’s what these 4 commands unlock:

• /goal

• /loop

• /schedule

• Stop Hooks

Once you understand them, Claude stops feeling like a chatbot and starts behaving more like an autonomous engineering partner.

The Big Shift

Traditional workflow looks like this:

You ask → Claude answers → you review → you ask again.

You’re managing every step manually.

With autonomous workflows, the flow changes completely:

You define the outcome once → Claude keeps working → checks progress automatically → stops only when the condition is met.

You stop babysitting the process.

Subscribe now

1. /goal — The Most Important Command

/goal is what turns Claude into a self-running agent.

Instead of giving step-by-step instructions, you define the final condition.

Example:

/goal all auth tests pass and lint returns zero errors

Claude starts working immediately.

After every turn, a lightweight evaluator checks whether the condition is satisfied.

If not, Claude continues automatically.

You don’t need to keep prompting.

Why This Changes Everything

Normally:

• You notice failing tests
  

• You ask Claude to fix them
  

• You rerun things
  

• You paste errors back
  

• Repeat 15 times
  

With /goal:

Claude keeps iterating until the condition is true.

It behaves more like:

“Keep working until this system is fixed.”

That’s a massive mindset shift.

Writing Good Goals

The secret is making goals measurable.

Good goals:

• “All tests in test/auth pass”
  

• “npm run lint exits successfully”
  

• “No unrelated files are modified”
  

Bad goals:

• “Improve the code”
  

• “Make it cleaner”
  

• “Do your best”
  

If the result cannot be verified clearly, the evaluator can’t reliably stop.

Simple rule:

If Claude cannot prove completion through the transcript, rewrite the condition.

Subscribe now

Always Add Limits

Some tasks may never fully complete.

That’s why limits matter.

Examples:

/goal fix checkout tests, or stop after 10 turns

/goal complete migration, or stop after 30 minutes

Without limits, Claude may loop forever trying to satisfy an impossible condition.

Fully Autonomous Mode

This is where things become powerful.

Combine:

• /goal
  

• Auto Mode
  

• Test-based Stop Hooks
  

Now Claude:

• edits code
  

• runs tests
  

• reads failures
  

• retries automatically
  

No human needed between iterations.

You come back later to:

• a green build
  

• or a clear explanation of why it failed
  

That’s incredibly close to a real autonomous coding agent.

2. /loop

/loop is different from /goal.

/goal says:

“Keep working until this becomes true.”

/loop says:

“Repeat this work every few minutes.”

Useful for:

• iterative refactors
  

• backlog cleanup
  

• monitoring tasks
  

• repeated checks
  

• gradual improvements
  

Example mindset:

Claude makes a pass → pauses → makes another pass later.

It’s continuous iteration instead of one long execution.

3. /schedule

This one feels almost like infrastructure.

/schedule lets Claude run tasks on a fixed cadence — even when Claude Code isn’t open.

Examples:

• nightly test runs
  

• morning issue triage
  

• weekly dead-code cleanup
  

• daily engineering summaries
  

Instead of manually remembering operational tasks, Claude handles them automatically.

That’s the difference between:

using AI occasionally

vs

building AI into your workflow itself.

4. Stop Hooks

Stop hooks decide whether Claude is allowed to stop.

This is what powers /goal internally.

There are two types:

Script-based Hooks

These run actual checks:

• test suites
  

• CI validation
  

• database checks
  

• file existence checks
  

If the script exits successfully → Claude stops.

If not → Claude keeps trying.

This is where true automation starts happening.

Prompt-based Hooks

These evaluate natural-language conditions using the conversation transcript.

Very similar to /goal, but reusable across sessions.

Use them when you want the same evaluation logic everywhere.

Subscribe now

The Most Powerful Combination

The real magic stack is:

/goal + Auto Mode + Script-based Stop Hooks

Now the loop becomes:

Claude writes code → tests run automatically → failures return → Claude retries.

No manual supervision required.

That’s the closest thing today to an AI engineer working independently inside your workflow.

Thanks for reading this article. Appreciated. Comments and suggestions are welcome.

Support the author here, If you found this blog helpful.

• If you’d like to chat 1:1, you can book a call with me here.

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Instagram

• Twitter

• Threads

I’ve been using Claude for some months now. The pro version.

But to be honest, for the last month, I’ve been feeling like this company is just looting me or may all of us. I sent 3 queries in 3 different context windows; as a result, I reached my usage limit for that time. Now, I have to wait for the next 5 fuc*ing hours to again continue on that project, which I scheduled to work on at that point of time.

Of course you guys might have heard the news that it’s true; the quality of response also decreased from last month. Boris also agreed & posted this yesterday.

I will write in this article about what I have been following after reading and watching lots of videos.

You know that when you sent the 10th message to Claude, it cost 11 times more than your first one. Not because of pricing; it’s because Claude re-reads your entire conversation history from scratch before generating every single reply.

Understanding why this happens is the first step to stopping it.

There is a developer named Aniket Parihar who shared a post where he tracked real usage and found 98.5% of tokens went to re-reading old history and only 1.5% to the actual response. For every 100 tokens spent, one and a half are doing useful work. The rest is the model reprocessing things it already knows.

Here are some rules to follow...

1. Don’t follow up, edit instead

When Claude gets something wrong, the instinct is to send a correction as a new message. Every correction you send appends to the conversation, & Claude loads all of it again next turn. Five messages deep puts you at ~7,500 tokens just for context.

Instead, click “edit” on your original message, fix the wording, and hit “regenerate.” The flawed exchange is replaced, not stacked. Same result, a fraction of the cost.

Why does it work?

LLMs like Claude use attention mechanisms that process every token in the context window at each generation step.

Longer context = quadratically more compute. Replacing a bad exchange eliminates it from future attention passes entirely, unlike a correction, which adds to the pile.

2. Start a fresh chat every 15–20 messages

A 100-message thread burns over 2.5 million tokens, almost all of it reloading history you no longer need. When a conversation gets long, ask Claude to summarize everything, copy that summary, open a new chat, and paste it as your first message.

You keep the relevant context. You shed all the resolved back-and-forth, early attempts, and dead ends that are still sitting in the pipeline, costing you money every turn.

Why does it work?

Context windows are fixed-size buffers. Every token of old conversation competes directly with new output space. A clean summary carries maybe 400 tokens of distilled knowledge vs. 50,000+ tokens of raw history. It’s not compression; it’s knowing what actually matters.

Share Growtechie

3. Batch your questions into one message

Three questions sent separately equals three full context reloads. One message with three tasks equals one reload. You save tokens twice: fewer context loads, and you stay further from your session limit with the same amount of work done.

Instead of “Summarize this” → “Now list the main points” → “Suggest a headline,” write “Summarize this, list the main points, and suggest a headline.” The answers are often better too. Claude sees the full intent before it starts writing.

Why does it work?

Each turn in an LLM conversation is a complete, stateless inference pass. There’s no “memory“ between messages; the model literally rereads everything. Batching collapses three inference passes into one, and the model can cross-reference all tasks simultaneously during generation rather than treating them as isolated requests.

4. Track your actual token usage

Claude’s UI shows a vague progress bar. That’s it. But if you use Claude Code, every session logs detailed JSONL files to your local machine: input tokens, output tokens, cache reads, cache creation, model names, timestamps, all of it.

He built a free, open-source Python dashboard that reads those files, builds a local database, and serves charts at localhost. You can filter by model, by time range, and see cost estimates based on current API pricing. You can’t fix what you can’t measure.

Github repo:

https://github.com/phuryn/claude-usage

Share Growtechie

5. Upload recurring files to projects

Uploading the same PDF to multiple chats re-tokenizes that document every single time. A 30-page contract might be 15,000 tokens. Upload it five times across five sessions and you’ve burned 75,000 tokens just loading a file. Claude has already seen.

The Projects feature caches uploaded content. Every conversation inside that project references the file without burning new tokens. For style guides, contracts, codebases, or any recurring reference material, this is one of the highest-leverage changes you can make.

Why does it work?

Anthropic uses prompt caching for project-level content; the KV (key-value) cache stores the computed attention states for those tokens. On subsequent reads, the model retrieves from cache instead of recomputing. Cache reads cost roughly 10% of full token processing, and in Claude’s pricing, cache reads are significantly cheaper than input tokens.

6. Save your context in memory once

Without saved preferences, most people spend 3–5 messages per new chat re-establishing context: their role, their writing style, what they’re working on. That’s 500–800 tokens gone before the actual work starts, repeated across every session.

Go to Settings → Memory and User Preferences.

Save your role, communication style, output format preferences, and any recurring project context once. Claude automatically pulls this into every new chat, and you skip the warmup tax entirely.

Share Growtechie

7. Turn off features you’re not actively using

Web search, connectors, and extended thinking all add overhead to every response, whether you’re using them or not. Web search adds retrieval scaffolding tokens. Extended thinking adds a chain-of-thought block before every reply. These costs compound across the session.

Keep everything off by default. Enable web search when you need current information. Enable extended thinking only when your first attempt was genuinely unsatisfactory. If you didn’t turn it on with intention, turn it off.

8. Match the model to the task

Using Opus to check grammar is like renting a freight truck to buy groceries. Haiku handles simple tasks like formatting, translation, quick answers, and brainstorming at a fraction of the cost. Choosing the right model is the highest-leverage decision you make each day.

• Haiku: (Low Cost) Drafts, formatting, grammar, quick lookups, translations

• Sonnet: (Medium Cost) Production output, code, analysis, complex writing

• Opus: (High Cost) Hard reasoning, multi-step logic, nuanced judgment

9. Spread your work across the day

Claude does not reset at midnight. It uses a rolling 5-hour window. Messages sent at 9 a.m. no longer count toward your limit by 2 p.m. If you burn through your entire budget in one morning session, you’re wasting the afternoon capacity that would have been available had you paced yourself.

Splitting into two or three sessions in the morning, midday, & evening. Lets each window partially expire before you start the next, keeping you well below the ceiling throughout the day.

Share Growtechie

10. Work during off-peak hours

Since March 26, 2026, Anthropic has depleted your 5-hour session limit faster during peak hours. The same query, the same chat, but during peak, it hits your limit harder. Your weekly total stays the same; how quickly it drains changes.

Pacific time: 5:00 am – 11:00 am – Weekdays only

Eastern time: 8:00 am – 2:00 pm – Weekdays only

Running intensive tasks in the evenings, on weekends, or during off-peak hours stretches your plan significantly. If you’re outside the US, Latin America, Asia, or Australia, your off-peak windows may fall during your morning, which is actually ideal. Here is the proof to it:

That’s it...

Hopefully you found it helpful. If you know something more, add it in the comment section. Would love to explore and see the result.

Thanks for reading this.

Share Growtechie

Most people learn neural networks by calling .fit() and watching accuracy go brrrrr.

That’s fine… until you realize you still don’t really know why anything is happening under the hood. This post is for the people who want to peel the black box open just a little.
We’re going to build a small but real neural network using only NumPy, step by painful-but-satisfying step. No PyTorch, no TensorFlow, no Flax, no Keras, no .backward(), no autograd.
Just matrices, loops, and the chain rule scribbled on paper (or in your head if you’re brave).

By the end you’ll have:

• written forward and backward passes yourself

• watched a loss number actually drop from “terrible” to “pretty decent”

• made a tiny network learn to guess someone’s gender from height & weight (classic toy example)

• understood why people scream about vanishing gradients, why sigmoid kind of sucks sometimes, and why backprop feels like reverse-engineering your own mistakes

If you already know:

• what a dot product is

• roughly how sigmoid squashes numbers between 0 and 1

• that training = repeatedly nudging weights to make predictions less wrong

…then you’re more than ready.
Even if some parts feel shaky, that’s okay. We’ll go slowly, look at shapes a lot, and print stuff to see what’s moving. Let’s open a notebook, and let’s build something that learns from scratch, together. Ready when you are.

Let’s start with one lonely, confused neuron…

1. One lonely neuron first: A single artificial neuron does two things:

a. weighted sum + bias

b. activation function

Source: Here. [Single Neuron]

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# Example: one input, one weight, one bias
x = 0.8
w = 1.5
b = -0.9
z = w * x + b           # linear part
y = sigmoid(z)
print(f”Output: {y:.4f}”)   # something between 0 and 1

Now the same thing, but cleaner as a class.

class SingleNeuron:
    def __init__(self, w, b):
        self.w = w
        self.b = b
    
    def forward(self, x):
        z = np.dot(self.w, x) + self.b
        return sigmoid(z)

# Multiple inputs now
w = np.array([0.4, -1.2, 0.7])
b = 0.1
neuron = SingleNeuron(w, b)
x = np.array([1.0, 2.0, -0.5])
print(neuron.forward(x))

That’s feedforward for one neuron. Easy.

So, what’s happening here?

Imagine you’re a very simple brain cell (a neuron) sitting inside a network. Your job is to look at several pieces of information coming toward you (in this case 3 numbers: 1.0, 2.0, and -0.5) and then decide how strongly you want to “fire” (send a signal forward). But you don’t treat all incoming signals equally.

• Some kinds of information excite you → you give them positive weight (like 0.4 or 0.7)

• Some kinds of information annoy/upset/inhibit you → you give them negative weight (like -1.2)

You get some numbers as input → x = [1.0, 2.0, -0.5]

Each has its own importance (weight) → w = [0.4, -1.2, 0.7]

You do:
(0.4 × 1.0) + (-1.2 × 2.0) + (0.7 × -0.5) = -2.35

Add your personal offset (bias) → -2.35 + 0.1 = -2.25

Then squash it with sigmoid → turns -2.25 into ≈ 0.095

So the neuron says, “I’m only ~9.5% activated right now.” That’s it.

Everything big (ChatGPT, Gemini & image models…) is just tons of these little guys connected together doing exactly this. The class just keeps the neuron’s “personality” (weights + bias) in one place and gives it a clean forward() button.

2. Let’s stack layers—a proper (tiny) network.

Most tutorials jump straight to training. I think it’s worth seeing the shapes first without training pressure.

Task: height + weight → probability (person is male)

Dataset (classic toy example):

# Let’s center roughly around median-ish values
X = np.array([
    [65-67, 133-140],   # roughly centered
    [72-67, 160-140],
    [70-67, 152-140],
    [60-67, 120-140]
])   # shape: (4, 2)

y = np.array([[0], [1], [1], [0]])   # (4, 1)

Network layout:

• Input: 2 features

• Hidden layer: 4 neurons (small but enough to learn something non-linear)

• Output: 1 neuron → sigmoid → probability

np.random.seed(42)

# Layer 1 (input → hidden)
W1 = np.random.randn(2, 4) * 0.3    # smaller init → stabler start
b1 = np.zeros((1, 4))

# Layer 2 (hidden → output)
W2 = np.random.randn(4, 1) * 0.3
b2 = np.zeros((1, 1))

# Forward pass (one time - no training yet)
z1 = X @ W1 + b1
a1 = sigmoid(z1)           # (4,4)
z2 = a1 @ W2 + b2
y_hat = sigmoid(z2)        # (4,1)

print(”Random network predictions (terrible):”)
print(y_hat.flatten().round(3))

You’ll see numbers all over the place; that’s expected.

3. The only thing that matters: how wrong are we?

We’ll use binary cross-entropy (most natural for 0/1 classification)

def bce_loss(y_true, y_pred):
    # tiny epsilon prevents log(0)
    eps = 1e-8
    return -np.mean( y_true * np.log(y_pred + eps) + 
                    (1 - y_true) * np.log(1 - y_pred + eps) )

4. Backpropagation—the heart of the whole thing

This is where most people get scared. The truth is it’s just the chain rule applied many times.

We want four things:

• ∂L/∂W2

• ∂L/∂b2

• ∂L/∂W1

• ∂L/∂b1

Luckily when you use sigmoid + BCE together, the math simplifies beautifully at the output layer:

# -----------------------
#        BACKPROP
# -----------------------

# Output layer gradients
dz2 = y_hat - y                        # (4,1)   ← magic simplification!
dW2 = (a1.T @ dz2) / len(X)            # (4,1)
db2 = dz2.mean(axis=0, keepdims=True)  # (1,1)

# Hidden layer gradients
da1 = dz2 @ W2.T                       # (4,4)
dz1 = da1 * a1 * (1 - a1)              # sigmoid derivative
dW1 = (X.T @ dz1) / len(X)             # (2,4)
db1 = dz1.mean(axis=0, keepdims=True)  # (1,4)

That’s literally it.

5. Training loop put it all together

learning_rate = 0.15
epochs = 4000

for epoch in range(epochs):

    # Forward
    z1 = X @ W1 + b1
    a1 = sigmoid(z1)
    z2 = a1 @ W2 + b2
    y_hat = sigmoid(z2)
    loss = bce_loss(y, y_hat)

    # Backward
    dz2 = y_hat - y
    dW2 = a1.T @ dz2 / len(X)
    db2 = dz2.mean(axis=0, keepdims=True)
    dz1 = (dz2 @ W2.T) * a1 * (1 - a1)
    dW1 = X.T @ dz1 / len(X)
    db1 = dz1.mean(axis=0, keepdims=True)

    # Update
    W2 -= learning_rate * dW2
    b2 -= learning_rate * db2
    W1 -= learning_rate * dW1
    b1 -= learning_rate * db1
    if epoch % 400 == 0:
        print(f”epoch {epoch:4d}   loss = {loss:.4f}”)

After ~3000–5000 steps (depending on init & lr), you should see:

epoch    0   loss = 0.6931
epoch  400   loss = 0.5124
epoch  800   loss = 0.3812
...
epoch 3600   loss = 0.0947

And final predictions usually look like [0.08, 0.94, 0.93, 0.06]—pretty solid for four points!

Quick test on new person

person = np.array([[68-67, 145-140]])   # ~68 inches, 145 lbs
z1 = person @ W1 + b1
a1 = sigmoid(z1)
z2 = a1 @ W2 + b2
prob = sigmoid(z2)[0,0]

print(f”Probability male: {prob:.3f}”)
print(”→ male” if prob > 0.5 else “→ female”)

Wrapping Up

You just did it.
You hand-wrote a neural network that actually learned to tell boys from girls using nothing but height, weight, some angry math, and way too many cups of chai. No fancy framework saved you. No magical .fit().

Just you, NumPy, the chain rule you probably cursed at least twice, and a loss that went from “what even is this” to “yo, that’s actually decent.” “You saw the predictions crawl from random garbage → kind of suspicious → pretty confident.

You felt the moment the numbers started listening to you. That little dopamine hit when the loss finally dropped below 0.1? Yeah, that’s the good stuff. You now know why sigmoid can be moody, why backprop is just guilt-tripping every weight for its bad decisions, and why people lose their minds over learning rates. Most importantly—you broke the spell.

Next time someone says, “deep learning is just black magic,” you can quietly smile and go, “…nah, I built one in like 60 lines. ”.

Thanks for reading this blog. Appreciated. Comments and suggestions for aspiring guys are welcome.

• If you’d like to chat 1:1, you can book a call with me here.

• Subscribe to my newsletter for a weekly post on a mix of technical topics and mindset/motivation for challenging fields.

• Subscribe to my YouTube channel. Will start uploading long videos soon.

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Instagram

• Twitter

• Threads

Most people read about LLMs. Very few actually build, break, and measure them.

This is a curated path of LLM engineering projects, where:

• each project teaches one core idea

• you implement it end-to-end

• you visualize what’s happening

• you ablate it, break it, and see why it matters

No hand-wavy theory.
No “trust the paper.”
Just code → plots → intuition.

1. Tokenization & Embeddings

The foundation everyone underestimates

Build

• Implement Byte Pair Encoding (BPE) from scratch

• Train your own subword vocabulary on raw text

See

• Write a token visualizer → map words/chunks → token IDs

• Compare one-hot vs learned embeddings

• Plot cosine distances between tokens

Core insight

Tokenization silently decides what your model can and cannot learn.

2. Positional Embeddings

Why order isn’t “obvious” to transformers

Build

• Implement:

  • Sinusoidal

  • Learned positional embeddings

  • RoPE

  • ALiBi

See

• Animate a toy sequence being position-encoded in 3D

• Ablate positional info and watch attention collapse

Core insight

Transformers are permutation-invariant by default.
Position is injected, not inherent.

3. Self-Attention & Multi-Head Attention

The mechanism behind everything

Build

• Hand-wire dot-product attention for one token

• Scale it to multi-head attention

See

• Plot attention weight heatmaps per head

• Mask future tokens → verify causality

Core insight

Multi-head attention isn’t redundancy — it’s specialization.

4. Transformers, QKV & Stacking

From components to a real model

Build

• Combine attention + residuals + LayerNorm → single transformer block

• Stack blocks → a mini-Transformer

• Train on toy data

Break

• Swap Q/K/V

• Zero them out

• Watch training explode

Core insight

Q, K, V are not interchangeable.
Their roles are asymmetric and fragile.

5. Sampling: Temperature, Top-K, Top-P

Generation ≠ decoding

Build

• Interactive sampler dashboard

• Tune temperature / k / p live

See

• Plot entropy vs output diversity

• Set temperature = 0 → watch repetition hell

Core insight

Sampling strategy matters as much as the model itself.

6. KV Cache (Fast Inference)

Why inference is fast… sometimes

Build

• Cache key/value states across tokens

• Compare inference speed with vs without cache

See

• Cache hit/miss visualizer

• Memory cost vs sequence length

Core insight

KV cache trades memory for massive speedups.

7. Long-Context Tricks

Why context windows lie

Build

• Sliding-window attention

• Memory-efficient attention variants

Measure

• Loss vs context length

• Find the “context collapse” point

Core insight

Long context ≠ long memory.

8. Mixture of Experts (MoE)

Sparse models, dense thinking

Build

• Simple 2-expert router

• Token-level routing

See

• Expert utilization histograms

• FLOPs saved vs dense layers

Core insight

Capacity scales better than compute — if routing works.

9. Grouped Query Attention

A performance trick with real tradeoffs

Build

• Convert multi-head attention → GQA

Measure

• Latency vs number of groups

• Throughput on large batches

Core insight

Most speedups come from architectural constraints, not magic.

10. Normalization & Activations

The quiet stabilizers

Build

• LayerNorm

• RMSNorm

• GELU

• SwiGLU

Ablate

• Remove each and retrain

See

• Activation distributions layer by layer

Core insight

Training stability is engineered, not guaranteed.

11. Pretraining Objectives

What you train for shapes what you get

Build

• Masked LM

• Causal LM

• Prefix LM

Compare

• Loss curves

• Generated samples

Core insight

Objectives bias behavior long before fine-tuning.

12. Finetuning vs Instruction Tuning vs RLHF

Alignment is layered

Build

• Plain finetuning

• Instruction tuning (“Summarize: …”)

• Tiny RLHF loop with PPO

Plot

• Reward vs steps

• Behavior shifts

Core insight

RLHF doesn’t teach skills — it reshapes preferences.

13. Scaling Laws & Model Capacity

When bigger actually helps

Build

• Tiny → small → medium models

Measure

• Loss vs size

• VRAM, throughput, wall-clock time

Extrapolate

• How small is too small?

Core insight

Scaling laws are empirical, not philosophical.

14. Quantization

Performance has a cost

Build

• Post-training quantization

• Quantization-aware training

Measure

• Accuracy drop vs bit-width

• Export to inference formats

Core insight

Compression reveals what the model truly relies on.

15. Inference & Training Stacks

Same model, different realities

Build

• Port one model across multiple stacks

Profile

• Latency

• Throughput

• VRAM usage

Core insight

Infrastructure choices shape model behavior.

16. Synthetic Data

Data is a lever

Build

• Generate toy datasets

• Add noise, dedupe, split

Compare

• Learning curves: real vs synthetic

Core insight

Good synthetic data beats bad real data.

Final Philosophy

One project → one insight

• Build it

• Plot it

• Break it

• Repeat

Don’t get stuck in theory.
Don’t wait for perfection.
Post what you learned, even the ugly graphs.

That’s how you actually learn LLMs.

See you in the next issue

Leave a comment

READ IT IF YOU ARE SERIOUS ABOUT IT.

As someone who has been teaching people in machine learning and data science-related subjects, I can see fear in my students every day. It’s not because they are dumb; it’s because they are worried about their future.

One thing for sure, for my students or any professionals who are in this field, is “You don’t need to be scared.”

Why?

Think about it. Please don’t read it while using Instagram Reels because it’s full of clown influencers who are giving you advice that makes no sense most of the time. They are the real parasite in your brain. The other day I saw a guy talking about FAANG, MAANG, BIG4 companies and ended up selling courses for some big companies…

I’m not saying they shouldn’t, as that’s their profession, but I’m just making you aware that you should stop following people like them or their roadmaps. People keep posting roadmaps all year just to make you confused. One guy will say,

“Math is secondary; you can ignore it.”

The other one will say:

“Dude, how can you go for interviews without a course certificate?”

You will keep following roadmaps and stuff, and the year will end. And that’s how you will be wasting another year. It’s not just those influencers’ fault. Its fault of yours as well.

What to do then?

Look, I’m not going to write this blog as a longer one but as an effective one, as I want everyone to read this.

First thing first, try to make a habit of sitting in one place and reading. Ok, bro, don’t just read novels. I’m talking about reading books here. Yeah, this is old school. People will find it dumb. I will tell those people

Shut up. Because people who read are going to do great things.

Why? Let me explain.

Reading books, specifically books in the machine learning or AI-related field, will make you smart. You will be speaking well. Your words in a sentence will be so classy when it comes to interviews. Because it matters. ML is a field where you don’t need to be really good at coding like an SDE job or backend job.

What matters the most is understanding data and business. If you have worked with Jupyter Notebook, you must have seen that as a fresher, you are coding one-liners in one cell. Eg:

df[:] = df.loc[:, df.columns.difference([‘ID’])]

This above one line is enough to remove the ID column while preserving the original DataFrame object reference. I mean, look at this; crazy!!

isn’t it?

That’s the power of Python and its libraries. You can just learn coding-related stuff easily. So, what’s there to learn then?

The things that most of these influencers don’t speak about.

UNDERSTANDING BUSINESS

If you are a guy who is starting a career in college trying to learn ML or even someone who is experienced and trying to switch jobs into the AI field, the most important thing is that you should understand the business side of your data.

And how is this going to be improved?

Simply work on different types of data. What I mean by that is pick datasets from different sectors. Read about that sector a bit. Learn what there is to understand. Read the dataset carefully. Don’t just jump into the project and coding in the notebook directly.

That’s stupidity. That’s where your patience to build a project will grow. You will understand things. As we all know, right? “Quality over quantity.” But still we all make the same mistake again and again. Don’t do that this time. Learn and build with patience.

Where to start?

Yes, this is really confusing for many people. But here is the thing. If you are totally into ML field, never ever start anything before Mathematics & Statistics. These 2 are the backbone of ML. Reach out to me on IG or X for math and stat resources for FREE. Once you are complete with this go for Python, SQL & ML basic models.

Never ever skip basic models & jump into the Deep Learning part. It’s needed, guys. These things will give you a lot of confidence; also, it’s something that is going to be asked in interviews. Once you will build some projects in classical machine learning models, jump into Deeep Learning after this.

As I have already told you guys, try making projects which are with new data, extract if you can by yourself.

• Make reference projects [Don’t put them on Resume]

• Make new ones [Put them on resume]

Projects matter, not your certificates.

How to learn effectively?

As you can see, if you are a fresher, you have so many things to learn to land an ML job. The real question is how should you learn them? There are some common paths. The right one depends on your background, time, and goals.

Open Source & Doing Everything by Yourself I always suggest students not to spend money nowadays on courses if you are a good self-learner. You should be the driver of your own learning path. You must design your own curriculum, stay motivated without deadlines, and actively seek feedback. Networking also becomes your responsibility. You need to attend meetups, contribute to open-source projects, participate in online communities, and reach out to people directly. This path works well for people who are self-driven and comfortable learning independently.

Also can check reference here: https://roadmap.sh/r/ml-engineer-3dqvu

For those who want more structure, Bootcamps and certificate programs are another option [I never suggest this at first place but if its less amount and you are lazy go for it.]. These programs provide clear learning paths, regular deadlines, mentorship, and a peer group. Many bootcamps also bring in industry professionals, which helps ensure that what you’re learning matches real job requirements. The main advantage is speed and accountability. The downside is cost, and the quality varies widely. The best programs have strong job placement records and partnerships with companies. Without that, they often become expensive versions of online courses.

Master’s degree is also an option. A master’s can be useful if you are targeting large tech companies that rely heavily on formal credentials and automated resume screening. I mean, in India you might be seeing a lot of people going to outside countries like US, AUS, CAN, NZ.….However, many programs are heavily theoretical and slow to adapt to changes in industry tools and workflows. The time and financial investment can be significant, especially if you study full-time.

I’m seeing a trend nowadays outside as well where MS students are struggling to get a job. So, the grass is always greener on the other side. Consider all things and then go for it.

Some people also consider PhDs, especially when they hear about cutting-edge AI research. In practice, a PhD is only valuable if you want to work in research or model development. The timeline is long, and the opportunity cost is extremely high. For applied AI engineering roles, this path is usually unnecessary.

So which path makes the most sense? For most AI engineering roles, especially at startups and mid-sized companies, a technical bachelor’s degree combined with strong self-study and real projects is enough. Bootcamps work well for people who already have a technical background and want to move quickly with guidance. Master’s degrees make sense if you are aiming for top-tier companies and can manage the cost without stepping away from work.

Regardless of the path, additional self-learning and project work are unavoidable.

What projects to make?

If you are building projects for yourself or for others, this framework helps you create work that actually stands out. As I already said before, build things that have some value. Not some random projects like “Titanic Dataset.” Ok!! That can be your reference project, but don’t put projects like those on your resume & hope you will get selected for interviews.

1. Start with a real interest
Choose a problem you genuinely care about. Curiosity and domain familiarity show up clearly in your decisions and explanations.

2. Use data that is not obvious
Avoid popular, ready-made datasets. Pull data from APIs, scrape websites, explore government or niche industry sources, or generate your own data through small experiments.

3. Think in systems, not notebooks
Build something end-to-end. Include data ingestion, storage, preprocessing, model usage such as RAG or fine-tuning, deployment, and a simple UI or API. This reflects how real products are built.

4. Add one “production touch.”
Even a small detail like logging, error handling, model evaluation, or monitoring makes your project feel real and professional.

5. Explain your decisions
Document not just what you built, but why you built it that way. Trade-offs, failures, and lessons matter more than perfect results.

6. Package and share intentionally
Create a clean GitHub repo with a clear README and setup steps. Add a demo, screenshots, or a short video. Then share it on LinkedIn, X, blogs, or meetups.

Strong projects tell a story. When your work shows real-world thinking and execution, job applications become a lot easier.

For Freshers Or Switching guys

When you do not have work experience, your resume needs to highlight what you can do. Put your AI skills at the top, make your projects easy to see, & add your portfolio link clearly.

On LinkedIn, avoid titles like “Student” or “Aspiring Data Scientist.” Position yourself by what you are building and working on, not what you hope to become.

This improves your chances, but automated filters can still block you. That is where networking matters.

Ok. One more thing. CONNECTIONS

Connection is not only about attending seminars or seeing resources or asking for referrals. A better approach is thoughtful outreach. Find people working in AI/ML at companies you just have in your list [I hope you have a list of companies in your mind ot noted down somewhere], whether they are hiring or not.

Do your homework. Read their blog posts, watch their talks, or read their papers. Then send a short message appreciating their work and asking a genuine question about a decision they made.

No job talk. No referral ask.

If a conversation starts, you can later ask for feedback on your resume or projects, or learn what skills their team values.

Most people ignore bad messages. But good, personal ones often get replies. The worst case is silence. The best case can change everything.

Want to see example. This is someone asking me for an internship role.

From my Linkedin DM

Hmm. What do you guys think will response to it? I ignored after this text.

Not Advice, But Remember!

AI/ML engineering takes time. Don’t think a 3 months learning period will make you knowledgable enought for an interview. For most people, learning the basics and building simple AI apps takes about 6 months if you already know some programming. If you are starting from scratch, expect closer to a year.

Getting comfortable with advanced concepts usually takes another 6 to 12 months. This is when your projects become more complex and your understanding gets deeper.

Reaching a solid professional level often takes 1 to 2 more years. Senior or lead roles come much later and usually require several years of real-world experience.

This plan is for someone who is patient enough. As per my reading and reports, till 2030 this field is going to demanded like never before. More hiring will happend. It’s just they are not going to hire some regular guys. Be unique and be productive. Be you.

Thanks for reading this blog. Appreciated. Comments and suggestions for apsiring guys are welcome.

Support the author here, If you found this blog helpful.

• If you’d like to chat 1:1, you can book a call with me here.

• Subscribe to my newsletter for a weekly post on a mix of technical topics and mindset/motivation for challenging fields.

• Subscribe to my YouTube channel. Will start uploading long videos soon.

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Instagram

• Twitter

• Threads

This story of mine will distill that discussion into a practical guide. No hype. No shortcuts.

Just what actually works.

Start With Fundamentals, Not Models

One of the biggest misconceptions beginners have is that ML research starts with training large models or fine-tuning checkpoints. It does not.

The right starting point is fundamentals.

A solid understanding of machine learning and deep learning concepts is non-negotiable. This can come from university courses or high-quality online resources. What matters is not the certificate but whether you understand what is happening under the hood.

Even though modern tooling abstracts away much of the complexity, research requires intuition. You need to understand why something works, not just how to run it.

Alongside ML and DL, undergraduate-level math is essential:

• Linear algebra

• Probability

• Calculus

You do not need to master everything upfront. You will revisit these topics repeatedly throughout your career. The goal early on is awareness and comfort, not perfection.

Avoid Tutorial Hell, Build Mental Models

A common trap is endlessly consuming courses without applying anything. This creates the illusion of progress without real learning.

The transition point is when you shift from courses to papers.

ML research is an active field. Breakthroughs happen regularly, and no course can keep up. Papers are how knowledge actually flows. Learning to read them is a core research skill.

Instead of treating papers like textbooks, think of them as nodes in a graph. Each paper builds on previous work and influences future directions. Your goal is to slowly build a mental map of the field.

A useful rule of thumb:

• Reading 5–20 papers in a subfield gives you working familiarity

• Around 50 papers gives you deep understanding

These numbers are not strict, but they help set expectations.

Learn to Read Papers Efficiently

Your first research paper might take a week to understand. That is normal and even healthy. It means you are actually trying to understand it.

Over time, you will naturally develop the ability to skim:

1. Read the title and abstract

2. Look at key figures and experiments

3. Jump to the conclusion and discussion

4. Decide whether the paper is worth a deep read

You do not need to read papers linearly. Most experienced researchers do multiple passes, each time extracting more insight.

You will also develop an internal classifier:

• Dataset paper

• Incremental improvement

• New technique

• New perspective on existing ideas

This skill only comes with volume and repetition. I would also suggest websites like

https://www.alphaxiv.org/

where you can communicate directly with the paper you are reading.

Use Citations to Build Your Research Graph

Papers do not come with tags, so discovering related work can feel confusing at first.

Two tools solve most of this:

• Backward search: use the related work section to see what the paper builds on

• Forward search: use Google Scholar to see who cited the paper

This lets you move backward and forward in time and gradually form clusters of ideas. You will often open many tabs, but you do not need to read everything deeply. Skimming is enough to build structure.

Predict the “Next Chapter”

One of the most powerful habits discussed was this: After reading a few papers on a topic, pause and ask yourself:

“If I were writing the next chapter in this field, what would it be?”

You will almost always be wrong. That is not the point.

The point is to train your mind to think like a researcher, not a student. In real research, the next chapter does not exist yet. Developing the habit of anticipating limitations, gaps, and natural next steps is crucial.

This separates passive learning from active research thinking.

The Missing Middle: From Reading to Research

Many people assume that once they read enough papers, ideas will automatically appear. This is rarely true. There is a missing middle stage.

That stage is hands-on experimentation with existing work.

Instead of re-implementing everything from scratch, focus on:

• Papers with open-source code

• Public datasets

• Reproducible results

Download the code. Run it. Break it. Modify it.

• Change datasets

• Tweak architectures

• Introduce new metrics

• Run ablations

This is how you learn what actually matters. In real research jobs, most work builds on existing codebases. Reinventing the wheel is rarely the goal.

Publishing your experiments as open source or writing blogs about your understanding creates public artifacts that matter far more than certificates.

How Much Math Do You Really Need?

Math is often the biggest psychological barrier. The truth is nuanced.

There are theoretical researchers who live in proofs and theorems. But many successful ML researchers are empirical researchers, focused on experiments, models, and evaluation.

For most people:

• Strong undergraduate math is required

• Advanced math is learned on demand

If a mathematical concept blocks your understanding, pause and learn it. If it is peripheral, it is okay to skip and revisit later.

Math provides intuition. It helps you understand why a loss function behaves differently or what a hyperparameter is really controlling. This intuition saves enormous experimental time.

Modern tools, including Gemini, can help explain papers and equations. Used wisely, they accelerate learning rather than replace it.

Working With Senior Researchers and Mentors

Research is not a solo sport.

At some point, progress depends heavily on mentorship. Senior researchers help with:

• Framing good hypotheses

• Designing meaningful experiments

• Building strong research narratives

• Avoiding obvious reviewer objections

Do not hesitate to email paper authors with thoughtful questions. Most researchers appreciate genuine interest.

Public artifacts matter here. Blogs, open-source repos, and reproductions make outreach far more effective.

Mentorship also matters because research hiring relies heavily on recommendations. There are far fewer research roles than software roles, and evaluating research ability in short interviews is hard. Trust and reputation play a large role.

The Lifecycle of a Research Project

A typical empirical research project follows this flow:

1. Identify a concrete problem

2. Decide how to evaluate it

3. Study existing literature

4. Find what is missing or broken

5. Form a hypothesis

6. Design experiments to validate or falsify it

7. Iterate and deepen insights

8. Write a clear story around the findings

Not every paper introduces a new algorithm. Valuable contributions include:

• New benchmarks or metrics

• Careful empirical observations

• Negative results

• New perspectives on existing methods

Good research is about insight, not novelty for its own sake.

Final Takeaway: Just Start, Stay Consistent

You do not need to check every box before starting ML research.

Start anywhere:

• A course

• A paper

• A code base

• A blog

What matters is consistency. Learning compounds. Small, regular effort beats sporadic bursts every time.

You do not need to be perfect to begin. You just need to begin.

And then keep going. This whole blog is inspired by a YouTube video by two Google researchers.

If you’d like to chat 1:1, you can book a call with me here.

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Instagram

• Twitter

• Threads

Leave a comment

Are you also hearing this word “OCR“ a lot lately?

I mean, I’m. Mostly by a lot of AI influencers and researchers. There are a lot of good projects and snaps on X. But don’t worry, this story is going to clear all your doubts as well, and you will get hands-on experience.

Imagine this, you’ve got a stack of documents like receipts, old letters, and a blurry photo of a textbook page. You need the text on them. Manually retyping all that? Ugh, impossible task.

Now imagine if your computer could just read those images and spit out the text for you. That’s OCR (Optical Character Recognition). It’s like giving your computer a pair of reading glasses and a dip into puberty.

Optical Character Recognition OCR is the technology that turns pictures of text (typed, handwritten, or printed) into machine-encoded text. It lets a program read words on a page much like we do, except it does it pixel-by-pixel instead of letter-by-letter. Once an image is digitized, OCR can search, edit, translate, or speak the text. It’s the secret behind scanning passports at the airport, digitizing books for Project, reading out loud to the blind, and even cracking CAPTCHAs (let’s not make it mad at us).

At its core, OCR is a fusion of image processing and pattern recognition. Traditional image processing might focus on classifying images or detecting objects, whereas OCR specifically hunts for text characters within an image. You can think of it as Photoshop doing shape analysis plus a bit of language logic: it cleans the image up, finds the letters, and then maps those shapes to alphabet symbols.

In practice, OCR systems often use a pipeline of steps to work their magic.

How OCR Works: From Pixels to Text

Optical Character Recognition (OCR) converts images of text like scanned documents or photos into editable, searchable digital text. At a high level, OCR works in three stages: preprocessing, character recognition, and post-processing.

1. Preprocessing: {Cleaning and Preparing the Image}

Before recognition begins, the image is enhanced to make text easier to read by the OCR engine.

- Deskewing: Rotates the scanned page so text lines are perfectly horizontal.

- Binarization: Converts the image to black and white, separating text (foreground) from the background.

- Noise Removal: Eliminates smudges, dots, and other visual distortions.

- Layout Analysis: Detects columns, text zones, and segments lines into words, while isolating images or tables.

Think of this stage as “priming the canvas,” preparing a clean, structured image that clearly presents the letters for recognition.

2. Character Recognition: The Core of OCR

This is where the system identifies what each character actually is.

Matrix Matching (Template Matching): Early OCR systems compared each detected character pixel-by-pixel with a library of stored glyphs. If the scanned “A” matched the stored “A” pattern, the system output “A”. This worked for clean, typewritten text but struggled with variations in font, handwriting, or image quality.

Feature Extraction: To handle greater variability, more advanced systems analyze the geometric features of characters — such as lines, curves, intersections, and loops.
For example, an uppercase “A” might be described as two diagonal strokes meeting at the top, connected by a horizontal bar.
This abstract representation makes OCR more flexible across fonts and styles.

Neural Network–Based Recognition: Modern OCR engines use deep learning models trained on millions of text samples. These models learn to recognize entire words or text lines at once, analyzing patterns much like how humans learn to read handwriting.
For instance, open-source tools like Tesseract now employ neural networks to process full lines of text rather than individual characters, dramatically improving accuracy.

3. Post-processing: Refining and Correcting the Output

After initial recognition, OCR applies post-processing to improve accuracy and readability.

Dictionary & Spell Checking: Corrects misread words by comparing them against a language dictionary or lexicon.

Contextual Correction: Uses language models to fix improbable letter combinations based on word context.

Layout Preservation: Keeps track of word positions to recreate the original formatting.

Some OCR systems even output searchable PDFs or HTML documents by maintaining the text layout alongside the recognized words.

Traditional Image Processing vs. OCR

You might wonder: isn’t OCR just another image processing task?

In a way, it is. It uses image processing (to clean images and find characters). But OCR has a distinct goal: interpret symbols as language.

Traditional image processing might do things like smoothing, edge detection, or face recognition, which care about shapes or objects in general. OCR specifically cares about letter shapes and word patterns. It even taps into language knowledge (dictionaries, grammar) in post-processing. So while OCR sits under the umbrella of computer vision, it’s tailored toward textual content. You could say OCR is the semantics layer of image processing: it doesn’t just see pixels, it reads them.

The rise of AI has blurred these lines. Modern OCR is often done by vision-language models (VLMs) that combine image encoders with language models. These AI-driven systems perform end-to-end OCR, sometimes even understanding layout (tables, figures, and multi-column text). We’ll see this next.

Advancements in OCR: Enter AI and DeepSeek

OCR has come a long way thanks to deep learning. Early OCR was rule-based or simple neural nets. Today’s systems use convolutional neural networks (CNNs), transformers, and massive image-text models. For example, Google’s Vision API or open-source tools like EasyOCR, PaddleOCR, and Tesseract’s latest versions all rely on deep networks trained on huge datasets. They can handle diverse fonts, lighting conditions, and even non-Latin scripts with impressive accuracy.

One exciting trend is Vision-Language Models (VLMs). These are AI models trained on both images and text, enabling them not only to recognize characters but also to understand documents as a whole. Projects like Qwen-VL, InternVL, and OCR2.0 have shown that a single model can both detect text regions and recognize the text all in one pass.

And then there’s DeepSeek OCR — a very hot new entry. DeepSeek OCR isn’t just about reading text better; it’s about a whole new vision of context processing. Traditional OCR (and most VLMs) treats text as long chains of tokens. DeepSeek says: “Hey, what if we see the text instead of reading it token by token?” It introduces Context Optical Compression: converting lengthy text into a compact visual form that an AI can digest faster. In practice, DeepSeek paints pages of text into images and uses a specialized encoder to compress them into “vision tokens.” Each visual token can carry much more information (font, layout, context) than a regular text token.

In simpler terms: imagine a 10,000-word document. A normal language model processes 10,000 tokens. DeepSeek’s approach might encode that into just ~1,000 visual tokens — a 10× compression! Remarkably, it can still output text at ~97% accuracy on standard benchmarks when compressed by 10×. Even at 20× (really crushing it down), it’s about 60% accurate — still useful for many tasks. This means faster inference with fewer computational steps. As one researcher put it, DeepSeek asks “are pixels better inputs to LLMs than text?”

DeepSeek isn’t a replacement for traditional image filters — it is image processing (it uses a CNN-based encoder) — but its goal is different. It’s designing an encoder so that a vision transformer can capture text information ultra-efficiently. The result is state-of-the-art OCR and document parsing with far fewer tokens needed.

Let’s zoom into the DeepSeek architecture, because it’s pretty cool.

DeepSeek OCR Architecture

DeepSeek OCR uses a two-part architecture: a DeepEncoder and a DeepSeek-3B-MoE Decoder. Think of the DeepEncoder as the “vision compression engine” and the decoder as a language model that spells out the text.

DeepEncoder: This is a custom image encoder with about 380M parameters. It’s built from two known pieces and a clever bridge. First, a SAM-based model (80M params) with windowed attention handles local visual details. Second, a CLIP-Large model (300M params) handles global context with full attention. Connecting them is a 16× Token Compressor (a stack of convolutions) that squashes thousands of patch tokens into just a few hundred “vision tokens.”

The result?

Even a 1024×1024 document turns into maybe a few hundred tokens, not millions. This keeps memory use low and speeds up processing.

DeepSeek-3B-MoE Decoder: Once the image is compressed into visual tokens, a transformer decoder (similar to a GPT) turns those tokens into text. DeepSeek uses a Mixture of Experts (MoE) design. At inference, only a small subset of the total “experts” are active (6 out of 64 plus 2 shared ones), giving it the power of a 3 billion parameter model but with the compute cost of a ~600M model. This decoder takes the vision tokens and the initial prompt (like “Convert the document to markdown”) and generates the textual output.

According to the creators, this design achieves incredible efficiency. On the standard OmniDocBench for documents, DeepSeek-OCR outperforms previous OCR models while using far fewer tokens. In practical terms, a single A100 GPU can process over 200,000 pages per day with DeepSeek. It’s a heavy-duty setup, but it shows that OCR can scale up massively.

DeepSeek also handles not just plain text but complex elements: tables, charts, chemical formulas, and diagrams—because it’s essentially an end-to-end document parser.

In short, it’s pushing OCR from just reading letters to understanding documents visually and semantically.

Hands-On with DeepSeek OCR

Enough theory!

Let’s do a quick project! We’ll use the open-source DeepSeek-OCR model to convert an image of text into actual text. We’ll walk through installing DeepSeek, loading an image, running the model, and getting the result.

Installation and Setup

DeepSeek-OCR is available on GitHub and Hugging Face, and it requires a recent Python environment (tested on Python 3.12 with CUDA 11.8). Here’s a simplified setup (you’ll need a decent GPU for reasonable speed):

# Clone the repository
git clone https://github.com/deepseek-ai/DeepSeek-OCR.git
cd DeepSeek-OCR

# Create a new environment (e.g., with conda or venv)
conda create -n deepseek-ocr python=3.12 -y
conda activate deepseek-ocr

# Install PyTorch (v2.6) with CUDA 11.8 support
pip install torch==2.6.0 torchvision==0.21.0 torchaudio==2.6.0 \
 - index-url https://download.pytorch.org/whl/cu118

# (Optional) If using vLLM tools: install the wheel
# pip install vllm-0.8.5+cu118-cp38-abi3-manylinux1_x86_64.whl
# Install Python requirements
pip install -r requirements.txt

# Install flash-attn for faster inference
pip install flash-attn==2.7.3

Alternatively, if you just want to use the model via Hugging Face Transformers, you can skip some repo steps and just install transformers, torch, tokenizers, etc, as shown below.

Model Overview

DeepSeek-OCR is a vision-language model. Under the hood it’s packaged as a Hugging Face Transformers model with custom code. You don’t need to implement the architecture yourself, you just load it by name. However, remember it’s large, so load it on a GPU.

Let’s load the model and its tokenizer in Python:

from transformers import AutoModel, AutoTokenizer
import torch

model_name = “deepseek-ai/DeepSeek-OCR”
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModel.from_pretrained(
    model_name, 
    trust_remote_code=True,
    _attn_implementation=’flash_attention_2’,
    use_safetensors=True
)
model = model.eval().cuda().to(torch.bfloat16)

Here we can use trust_remote_code=True because DeepSeek provides custom model code. We also move the model to GPU and use bfloat16 for speed (supported on recent GPUs)

Loading and Preprocessing the Image

DeepSeek-OCR’s inference API expects an image file. You can use JPEGs, PNGs, etc.

Let’s say we have a scanned document document.jpg. We can simply give the file path to the model. (Under the hood, it will use Python Imaging Library to open it.)

If you need to manipulate the image (deskew, crop, etc.), you could do that with OpenCV or PIL beforehand, but DeepSeek will handle splitting large images. Its default mode is to use a “base_size” of 1024 and an “image_size” of 640, with crop_mode=True – this means it will take 1024×1024 crops of the page and also 640×640 crops, covering the whole document.

You could adjust these parameters for different performance/accuracy trade-offs (the README notes tiny/small/base/large modes).

For simplicity, let’s just feed the image path:

image_path = “path/to/document.jpg”

Running Inference

Now we define a prompt and run the model.

DeepSeek uses special tokens to indicate image input. A common trick is to use the <|grounding|> token with a query like “Convert the document to markdown.” You can also use “<image>\nFree OCR.” for plain text output. Here’s an example:

prompt = “<image>\n<|grounding|>Convert the document to markdown.”
res = model.infer(
    tokenizer,
    prompt=prompt,
    image_file=image_path,
    output_path=”ocr_output”,
    base_size=1024,
    image_size=640,
    crop_mode=True,
    save_results=True
)

This runs the OCR. Behind the scenes, DeepSeek’s encoder compresses the image, then the decoder generates text. If save_results=True, it will write output files (by default Markdown and image PNGs) into the directory ocr_output. The res object also contains information. For example, res[’text’] will have the recognized text. (You can omit output_path and save_results if you just want the Python return value.)

After calling model.infer, you might print or examine the result:

print(res[’text’][:200])  # print the first 200 characters

You should see text that closely matches the contents of your scanned page, possibly with Markdown formatting (headers, bullet points) if you used the Markdown prompt.

The deepseek-ai model card on Hugging Face shows very similar code examples, confirming this usage

Post-Processing and Exporting Results

Once you have the text, you can clean it up or export it. For example, write it to a file:

with open(”recognized_text.md”, “w”) as f:
    f.write(res[’text’])

Because we asked for Markdown, the output may contain # for headings, lists, or even images if they were in the document. You can also post-process to plain text if needed (strip extra markup or fix hyphenation). OCR isn’t perfect: you might see minor errors or formatting issues, especially on low-quality scans or odd layouts. Common fixes include spell-checking, using a vocabulary to correct misrecognized words, or manual review.

DeepSeek-OCR even provides vocabulary/”whitelist” options in advanced use (see the code samples using SamplingParams in the GitHub repo). But for many uses, a simple clean save is enough.

Finally, you can use the text however you need: index it in a search engine, feed it to another AI, or just read it on the screen. For instance, you could do:

print(”### Extracted Text:\n\n” + res[’text’])

Implement Deepseek-OCR Paper:

This below is the project structure of the research paper implementation in smaller level. You can check out my github repo here:

https://github.com/Ramakm/Deepseek-OCR

Deepseek-OCR/
├── configs/ # Model and mode configurations
│ ├── model.yaml
│ └── modes.yaml
├── models/ # Model implementations
│ ├── deepencoder/
│ │ ├── sam_stage.py # Window attention stage
│ │ ├── compressor.py # 16× token compressor
│ │ ├── clip_stage.py # Global attention stage
│ │ └── deepencoder.py # Full encoder
│ ├── decoders/
│ │ ├── lm_decoder.py # LM decoder
│ │ └── moe_layers.py # MoE (optional)
│ └── ocr_model.py # End-to-end model
├── utils/ # Utilities
│ ├── image_io.py # Image loading & preprocessing
│ ├── metrics.py # CER, WER metrics
│ ├── prompts.py # OCR prompts
│ └── …
├── scripts/ # Training & inference
│ ├── infer.py
│ ├── train_encoder.py
│ └── train_ocr.py
├── evaluation/ # Evaluation scripts
│ ├── evaluate_ocr.py
│ └── baselines/
│ ├── tesseract_eval.py
│ └── paddle_eval.py
├── demo/ # Demo application
│ └── app.py
├── data/ # Data directory
└── docs/ # Documentation
└── ARCHITECTURE.md

Remember, I remove my dataset from opensource. Your work is to:

1. Add training data and run Stage 1 + 2 training

2. Test on sample images using the inference script

3. Evaluate against Tesseract/PaddleOCR baselines

4. Launch demo with python demo/app.py

5. Scale up by upgrading to larger backbones (Swin-B, CLIP-L, LLaMA)

Any help, just comment here. All the best for implementation of this.

Share Growtechie

Leave a comment

So how is it that your smartphone today can run AI tasks like real-time photo enhancement, voice recognition, or AR effects so effortlessly?

The answer lies in a new category of processors: Neural Processing Units (NPUs), or what Apple calls the Neural Engine.

The Problem With Old Chips

Neural networks are powered by math; specifically, endless streams of matrix multiplications. Unfortunately, this math was a terrible fit for traditional processors.

➤ CPUs excel at complex, one-at-a-time tasks. Perfect for logic-heavy programs, terrible for repetitive math.

➤ GPUs improved things with parallelism, but they’re still built as general-purpose graphics engines, carrying overhead not needed for AI.

Both were good enough for early AI experiments, but they were never designed for the kind of scale modern neural networks demand.

The Rise of the Neural Processing Unit

Enter the NPU, a third pillar of computing. Unlike CPUs and GPUs, NPUs shed general-purpose design and focus entirely on one job: running neural networks as efficiently as possible.

How?

➤ Dedicated hardware (MAC units): The chip is packed with thousands of tiny circuits whose sole job is to multiply two numbers and add them to a total. This is the essence of matrix multiplication.

➤ Systolic arrays: Instead of constantly pulling data from slow memory, systolic arrays pipeline data through the chip in rhythmic flows. This reuses data efficiently and avoids the memory bottleneck that plagues CPUs and GPUs.

➤ Low-precision arithmetic: Neural networks don’t need full 32-bit precision. By using formats like FP16 (16-bit floating point), NPUs double performance and halve memory use with almost no impact on accuracy.

Put simply, NPUs are factories for matrix math, and that makes them game-changers for AI.

Apple’s Secret Advantage

The most famous NPU today is the Apple Neural Engine (ANE). But what makes it special isn’t just raw power; it’s how deeply it’s integrated into Apple Silicon.

Apple designed the ANE as part of a tightly integrated SoC (System on Chip), where every component works together. Here’s why that matters:

➤ Workload offloading: By pushing AI inference to the ANE, the CPU and GPU are freed up for other system tasks. This prevents stutters and saves battery.

➤ Unified memory architecture (UMA): Instead of separate memory pools for CPU and GPU (like traditional PCs), Apple uses one high-bandwidth memory pool accessible by all processors. No data copying, no wasted energy.

➤ System-level cache (SLC): Frequently used data is kept close to all processors, avoiding expensive trips to DRAM.

This vertical integration means Apple devices don’t just perform well in benchmarks; they feel fast and efficient in real-world use.

Beyond TOPS: Real-World AI Performance

You’ll often hear chipmakers brag about “TOPS” (tera-operations per second) when marketing NPUs. While impressive, raw numbers don’t tell the full story.

The true performance of the Apple Neural Engine comes from its system-level design, the synergy of unified memory, shared cache, and workload balance across CPU, GPU, and NPU. It’s not just about how many operations per second the chip can perform, but how smoothly those operations integrate with the entire system.

Final Thoughts

The Neural Engine is more than just another chip; it represents a new pillar of computing. Alongside CPUs and GPUs, NPUs are now essential for the AI-powered experiences we take for granted every day.

Apple’s approach highlights an important truth: raw performance numbers don’t tell the whole story. Real breakthroughs come from system-level thinking, where hardware and software are designed hand-in-hand.

Without NPUs, AI on your phone would still be impractical. With them, it’s invisibly and seamlessly enhancing your photos, transcribing your voice, and powering intelligent features in the background.

The NPU turned the “impossible” into the everyday. And it’s only the beginning.

Thank you for reading this. Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Twitter

• Threads

• Instagram

So you want to be a GenAI Engineer (or AI Engineer)?

Great choice; it’s one of the most exciting fields right now. But let me tell you a secret: most candidates completely bomb their GenAI interviews.

Why?

Because they think building a chatbot with LangChain + Pinecone = Industry-ready.

Spoiler: it’s not.

Let’s break down how these interviews are usually structured, why people fail, and what you can do to stand out.

The 4 Layers of a GenAI Interview

Think of the interview process like a video game. You don’t just fight the boss, you need to get through the mini-bosses first. Each layer tests if you can move beyond being a demo builder to an end-to-end system thinker.

1. Foundations (Coding & DSA)

Yes, even in GenAI roles, the basics matter.

You’ll often start with a coding round where they check:

-> Arrays, strings, hashmaps, dynamic programming

-> Python fluency (OOP and functional patterns)

-> SQL queries (because AI without data is… useless)

You might think, “But I’m here to work on LLMs, not bubble sort!”

True. But interviewers want to see if you can think algorithmically, optimize queries, and write clean, modular code. If you can’t pass this round, no amount of “I built a chatbot with GPT-4” will save you.

2. Machine Learning & GenAI Basics

Now we’re talking! This is where the AI-specific grilling begins:

• Transformers, embeddings, and the attention mechanism

• Tokenization, context windows, and latency trade-offs

• Prompt engineering vs fine-tuning (when to use which)

Many candidates can use an embedding API. Very few can explain what embeddings are or why their choice of chunk size and tokenizer impacts latency and cost. That’s the difference between someone who can debug a production issue and someone who… Googles it in panic.

3. System Design (GenAI / RAG / LLM Pipelines)

This is where most candidates freeze. The interviewer might say:

• Design a multilingual RAG pipeline.

• Handle retrieval at scale; say 100M+ documents.

• What if the OpenAI API fails? How do you design fallback orchestration?

• How do you guard against hallucinations?

It’s not about code anymore; it’s about thinking like an architect. Can you design something that works not just for 10 users, but for 10 million?

This is also where terms like "hybrid search," "rerankers," "caching," and "sharding" show up. If those sound scary, don’t worry; they’re learnable.

The key is to practice thinking in trade-offs: latency vs accuracy, cost vs scale.

4. End-to-End Thinking

Finally, the big picture. Imagine you’ve built this shiny GenAI pipeline. The interviewer now asks:

• How does this fit into a real product?

• How would you monitor it in production?

• What’s your cost optimization strategy?

• How do you handle governance, compliance, and data privacy?

Because real-world GenAI isn’t about making cool demos. It’s about shipping systems that don’t bankrupt your company, don’t hallucinate into lawsuits, and actually create business value.

Why Candidates Fail

Here’s the brutal truth: After speaking with lots of guys over Twitter Spaces, I got to know that most of the guys preparing for GenAI interviews get stuck at the toy demo level. They build a chatbot with LangChain and Pinecone and think that’s enough to impress. It’s not.

When the real interview comes, they stumble because they don’t understand the trade-offs that matter in production, things like balancing latency with accuracy or optimizing costs while scaling to millions of users. Even worse, they often can’t explain why they made certain design choices in the first place.

And perhaps the biggest gap?

They never connect the dots. They know a bit of ML theory, and they know how to glue together a demo, but they can’t show how that knowledge translates into system design and, ultimately, business impact.

In short: they act like hackers, not engineers. And companies aren’t looking for hackers; they’re looking for engineers who can think end-to-end.

Best System Design Book for you is by the GOAT writer, Chip Huyen.

Find books like these which will be helpful to you for Data Science or AI/ML Engineering interviews here. The list is having lots of books pdfs, interviews materials, cheat-sheets and many more class notes. Go grab it now.

How to Actually Stand Out

The good news? You don’t need a PhD or a decade of research experience to shine in a GenAI interview. What you need is clarity, structure, and practice.

Start by mastering the basics: embeddings, retrieval, chunking strategies, and rerankers. It’s not enough to just use them; you should understand them deeply. If you can clearly explain, for example,

why you’d use cosine similarity instead of dot product in a retrieval setup, you’re already ahead of most candidates.

Next, show system design thinking. Don’t just describe how you’d chain APIs together. Practice sketching real pipelines, adding caching, hybrid search, and monitoring into your designs. Even if you do it on paper, interviewers notice when you think like an architect instead of a scriptwriter.

Equally important: learn to tell a story. Don’t dump jargon. Instead, walk the interviewer through your thought process: “Here’s the problem, here’s my design, here’s how it scales, and here are the trade-offs I considered.”

That kind of structured explanation makes people lean forward and actually listen.

Finally, practice with real-world scenarios. Think about how you’d design a multilingual RAG system, or how you’d orchestrate workflows with n8n or LangGraph. Consider pipelines that are cost-aware and resilient when APIs fail. The goal is to step beyond “demo-land” and into the mindset of solving real problems that companies face.

My “Gyan” [Thoughts]

Let’s be honest, no company is paying six figures just for another “Hello World chatbot.” They’re paying for systems that can survive real users, real data, and real CFOs asking, “Why did our bill triple last night?”

So don’t just memorize answers. Build your story, think like an architect, and show that you can connect the dots from ML theory → system design → business value.

That’s the difference between being the candidate who gets a polite rejection email… and the one who makes the interviewer whisper, “Finally, someone who gets it.”

You know, it went well. We all learn rejections, too. But if you are reading this blog, please try to do 50–60% of what I have mentioned. Thank me later here. Or if you did well, you can always thank me here.

Thank you for reading this. Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Twitter

• Threads

• Instagram

  ---

If you’re serious about breaking into AI and Machine Learning, you don’t need to spend thousands of dollars on courses. Some of the best teachers, researchers, and practitioners are already sharing world-class knowledge—for free—on YouTube.

The trick?

Stay consistent. Treat it like a self-paced degree: pick one channel, watch one lecture daily, and build along.

Here are 10 YouTube channels every aspiring AI/ML learner should bookmark 👇

1. Andrej Karpathy

Watch here
Andrej, former Tesla AI director and one of the brightest minds in deep learning, shares practical deep dives on neural networks, transformers, and even training models from scratch. If you want “from first principles” clarity, this is gold.

2. sentdex (Harrison Kinsley)

Watch here
Perfect for hands-on learners. Harrison covers everything from Python basics to advanced ML and deep learning projects. His full-length series can take you from zero to building your own applications.

3. Sebastian Raschka

Watch here
Author of Python Machine Learning and Machine Learning with PyTorch and Scikit-Learn, Sebastian explains LLMs, training pipelines, and cutting-edge research with clarity.

4. Jeremy Howard (fast.ai)

Watch here
Co-founder of fast.ai and creator of the famous “Practical Deep Learning for Coders” course. If you want to quickly build working AI systems with less math overhead, Jeremy’s teaching style is unmatched.

5. MIT OpenCourseWare

Watch here
Legendary. Entire university courses—AI, ML, deep learning, linear algebra, CS—free and open. Harder to follow casually, but if you commit, this is as good as a formal MIT education.

6. Stanford Online

Watch here
From Andrew Ng’s classic Machine Learning lectures to modern deep learning seminars, Stanford shares lectures straight from its classrooms. Great mix of theory and cutting-edge research.

7. StatQuest with Josh Starmer

Watch here
Math and stats form the foundation of ML. Josh explains these concepts with humor, clarity, and memorable visuals. If equations scare you, StatQuest will change that.

8. 3Blue1Brown

Watch here
Beautiful, visual explanations of math—linear algebra, calculus, neural networks—that help you build true intuition. A must-watch for understanding why ML algorithms work.

9. Krish Naik

Watch here
Industry-focused tutorials covering end-to-end ML and deep learning projects. Krish also shares interview prep and practical career guidance for aspiring data scientists.

10. CampusX

Watch here
Hands-on, beginner-friendly tutorials designed for students and working professionals. Covers projects, ML workflows, and practical AI applications.

YouTube is quietly the largest free AI/ML university on the planet.

Action plan:

• Pick one channel.

• Watch one lecture daily.

• Build something small each week.

Do this for 6–12 months, and you’ll have the equivalent of a degree—without the debt.

If you want to read books, I have a good collection of books for Data Science, AI/ML related. This list contains Books, PDF, Notes, Interview prep & Cheet-sheets.

Visit here: Books & PDFs for Data Science

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Twitter

• LinkedIn

• Instagram

• Threads

If you’ve ever searched for “best AI GitHub repos” or clicked on an “awesome AI” list, you know the pain. Dozens of starred projects, endless README files, and code that either doesn’t run or hasn’t been updated since 2021.

I’ve been there. I wasted 100+ hours testing, breaking, and fixing repos so you don’t have to.

Instead of dumping another giant list, I’ll share the hand-picked repositories that actually ship, why they’re worth your time, and how to approach learning from them as a beginner.

Why do repos matter more than books? [Not always]

Books are great for structured learning. But AI is moving too fast. By the time a book is published, frameworks change, APIs break, and the “latest” model is already old news.

GitHub repos, on the other hand, are living projects. They contain code you can run today, not just theory.

The catch? Most repos are messy, incomplete, or abandoned.

That’s why curating the right ones is key. If you’re a student or beginner, a single well-maintained repo can teach you more than months of scattered YouTube tutorials.

Top-5 AI repos that actually ship

1. Hands-On LLMs by Paul Iusztin & Maxime Labonne

🔗 GitHub Repo

Forget the book. The notebooks alone are pure gold.
Chapter 7 on deployment saved me twice when I couldn’t figure out how to get a model running in production.

Why learn it?
Because deployment is where most students get stuck. Building models is one thing; serving them to real users is the real game.

2. AI Agents for Beginners by Microsoft

🔗 GitHub Repo

Misleading title. This is not beginner level; it’s closer to intermediate. But if you’ve played with LLMs before, you’ll love Lesson 8 on memory patterns. It’s a masterclass in building agents that actually remember things.

Why learn it?
Because most “chatbots” today are goldfish. Memory turns them into something closer to Jarvis.

3. GenAI Agents by Nir Diamant

🔗 GitHub Repo

This repo is 90% theory, 10% working code. But that 10%? Worth cloning.
Think of it as a crash course in how to think about agents before you build them.

Why learn it?
Because copying code without understanding is useless.

Theory here = fewer headaches later.

4. Made with ML by Goku Mohandas

🔗 GitHub Repo

Most people skim this repo and ignore the MLOps section. Big mistake.
That’s where you learn about pipelines, monitoring, and scaling; the stuff that makes AI more than a cool demo.

Why learn it?
Because employers (and investors) don’t pay for models. They pay for systems that work reliably.

5. Prompt Engineering Guide by Elvis S.

🔗 GitHub Repo

This repo has tens of thousands of stars… And yet most people never read beyond page 3.
Pro tip: Skip the basics and go straight to the advanced prompt engineering section. That’s where the fun begins.

Why learn it?
Because LLMs are only as good as the prompts you feed them. This repo is like cheat codes for ChatGPT, Claude, or Gemini.

AI is evolving faster than any field we’ve seen before.

The good news? You don’t need to learn everything.

Pick one repo. Learn it deeply. Ship something real. That’s how you grow.

And if you’re overwhelmed by “awesome lists,” just remember:
I wasted lots of days, so you don’t have to.

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Twitter

• Instagram

• Threads

Share Growtechie

In today’s AI-driven world, terms like semantic search, vector embeddings, and retrieval-augmented generation (RAG) are becoming part of everyday tech vocabulary. I follow most of the AI techies on X [Twitter]. I mean, every other day I see something related to Vector DB.

Vector database — a powerful, behind-the-scenes engine that makes AI smarter, faster, and more context-aware.

In this post, I’ll walk you through what a vector database is, how it works, why it’s important, and how it compares to traditional databases. Covers the theory, compares tools, shows real use cases, and includes a practical Python tutorial using Sentence-Transformers + Qdrant (local).

Please, your support means a lot to me. Claps would help this blog reach more people. I have spent a good amount to write this. Hopefully it reaches to all who are searching to learn Vector DB. Read my other blogs here:

Let’s start with vectors

A vector, in the context of AI, is a numerical representation of data. It could be a sentence, an image, or even an audio clip — converted into a long list of numbers (often 100 to 1,000+ dimensions) that captures its meaning or features.

Let’s take an example:

“Paris is the capital of France.” 

→ [0.13, 0.92, -0.34, …, 0.45]

These are called embeddings, and they’re the reason LLMs can understand the semantic similarity between “Paris” and “London” better than just comparing strings.

But storing and searching through millions of these high-dimensional vectors isn’t what traditional databases (like MySQL or MongoDB) were built for.

That’s where vector databases come in.

What is a vector database?

A vector database is a purpose-built system designed to store, index, and search through vector embeddings efficiently — especially at scale.

Unlike traditional databases that match rows or columns, vector databases return results based on semantic similarity.

Here’s what that means:

• Traditional DB: Find “apple” == “apple”

• Vector DB: Find “apple” ≈ “fruit,” “granny smith,” “orchard”

Embeddings are usually produced by models like transformers (BERT family), CLIP (for images + text), or Sentence-Transformers for sentence-level embeddings.

How vector databases actually work (indexing, ANN, distance metrics)

The core problem: nearest neighbour search

Given a query vector, find the most similar vectors in a large collection. Brute force compares the query to every vector (O(n) time) — slow when n is millions. Vector DBs solve this using Approximate Nearest Neighbour (ANN) techniques and optimized indexing.

ANN algorithms (theory, briefly)

It’s a type of nearest neighbour search and a technique used in vector databases to find data points closest to a given query point with a certain level of approximation.

Unlike exact nearest neighbour searches, ANN focuses on speed and efficiency, accepting a small degree of approximation for significantly faster results. This approach is particularly effective in high-dimensional spaces, typical in modern AI applications, where exact matching is computationally intensive.

E.g., image recognition systems. (ANN can analyze an image, convert it into a vector, and compare it to a database of image vectors.) , Music streaming services, Medical imaging.

Steps involved:

• HNSW (Hierarchical Navigable Small World) — builds a layered proximity graph to navigate quickly from coarse to fine neighborhoods. Many modern vector DBs use HNSW as a default for its strong speed/accuracy tradeoffs.

• IVF (Inverted File) and Product Quantization (PQ) — commonly used in FAISS and some DBs to compress vectors and shard search space.

• ScaNN, Annoy, LSH — other options, chosen based on size, accuracy needs, and memory constraints.

  

Similarity metrics

Vectors can be represented as lists of numbers or as an orientation and a magnitude. For the easiest way to understand this, you can imagine vectors as line segments pointing in specific directions in space.

Let’s check how to calculate it?

There are several ways to calculate the similarity (or distance) between two vectors, which we call metrics. The most popular ones are:

Dot Product: Obtained by multiplying corresponding elements of the vectors and then summing those products. A larger dot product indicates a greater degree of similarity.

Cosine Similarity: Calculated using the dot product of the two vectors divided by the product of their magnitudes (norms). Cosine similarity of 1 implies that the vectors are perfectly aligned, while a value of 0 indicates no similarity. A value of -1 means they are diametrically opposed (or dissimilar).

Euclidean Distance: Assuming two vectors act like arrows in vector space, Euclidean distance calculates the length of the straight line connecting the heads of these two arrows. The smaller the Euclidean distance, the greater the similarity.

Manhattan Distance: Also known as taxicab distance, it is calculated as the total distance between the two vectors in a vector space, if you follow a grid-like path. The smaller the Manhattan distance, the greater the similarity.

and many more. One of the best place to know about this here.

Purpose-built vs extension-based vector databases

Purpose-built vector DBs

Examples: Qdrant, Pinecone, Weaviate, Milvus, Chroma. They:

• Optimize ingestion, indexing, filtering, and ANN out of the box.

• Offer features like metadata filtering, hybrid search (vector + scalar filters), multi-vector per record, and scaling options

• They are best for production RAG, recommendation engines, and high-query workloads.

Extensions on traditional DBs

Examples: PostgreSQL + pgvector, Redis Vector Search, Elasticsearch with vector modules.

• Good if you already run PostgreSQL or Redis and want to add vector search without introducing a new system.

• May trade off some ANN performance or advanced features compared to purpose-built systems. Still a smart choice for simpler use cases or when ACID compliance is critical.

Popular systems — short, researched comparison

• Pinecone — a fully managed, serverless vector DB with auto-scaling and enterprise integration. Great for RAG in production. Pinecone

• Qdrant — open-source, Rust-based, great performance and filtering; easy local quickstart with Docker. Good for building production-ready systems while keeping control.

• Weaviate — open-source with a GraphQL front-end — supports built-in ML modules and knowledge-graph-style features.

• pgvector (Postgres) — adds vector column + similarity functions to PostgreSQL; ACID, SQL familiarity. Great for teams already in Postgres.

• Milvus, Chroma, and FAISS — Milvus for large distributed GPU workloads; Chroma for local LLM workflows; and FAISS is a library used inside other systems for ANN. (FAISS is not a full DB by itself but a foundational library.)

Real-world architectures and use cases

• RAG (Retrieval-Augmented Generation): Index documents as embeddings in the vector DB; at query time, retrieve top-K documents and pass them as context to your LLM. Popular pattern for building chatbots with long context. (Pinecone + OpenAI is a common combo in tutorials.)

• Recommendation engines: For “people who liked this also liked…,” compute user and item embeddings and perform nearest neighbor queries.

• Multimodal search: CLIP embeddings for images and text allow cross-modal search (text → images and vice versa).

• Hybrid search: Combine vector retrieval with keyword/SQL filters (e.g., “top-10 similar articles from 2024 only”).

HANDS-ON TUTORIAL — Build a local semantic search with Sentence-Transformers + Qdrant

This is a compact, runnable tutorial. We’ll:

1. Install dependencies.

2. Run Qdrant locally via Docker.

3. Generate embeddings with Sentence-Transformers (all-MiniLM-L6-v2).

4. Index documents into Qdrant.

5. Query similar documents.

Why this stack? Qdrant has an excellent local quickstart and Python client; Sentence-Transformers provides easy, quality embeddings for semantic search. Both have well-documented guides.

My Suggestion: This tutorial is local/educational. For production, consider secure managed instances, bigger models, and batching with async upload.

A. Setup (commands)

Run in terminal:

# create a virtual env (optional)
python -m venv venv
source venv/bin/activate

# install Python libs
pip install qdrant-client sentence-transformers numpy uvicorn fastapi

Start Qdrant locally (Docker recommended):

# start a Qdrant container (requires Docker)
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant

B. Example dataset

Create a small sample corpus (Python list) — in real life you’d use articles, product descriptions, or PDFs.

documents = [
    {"id": "1", "text": "How to cook perfect pancakes: recipes and tips."},
    {"id": "2", "text": "Best practices for PostgreSQL performance tuning."},
    {"id": "3", "text": "A beginner's guide to machine learning and neural networks."},
    {"id": "4", "text": "Top 10 travel destinations for food lovers in 2025."},
    {"id": "5", "text": "Understanding vector databases and semantic search."}
]

C. Encoding + Uploading to Qdrant (full Python script)

# filename: qdrant_semantic_search.py
from qdrant_client import QdrantClient
from qdrant_client.http.models import Distance, VectorParams
from sentence_transformers import SentenceTransformer
import numpy as np

# 1 Connect to local Qdrant
client = QdrantClient(url="http://localhost:6333")

# 2 Create collection (if not exists)
collection_name = "demo_docs"
if collection_name not in [c.name for c in client.get_collections().collections]:
    client.recreate_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(size=384, distance=Distance.COSINE)  # using all-MiniLM-L6-v2 -> 384 dims
    )
# 3 Load the embedding model
model = SentenceTransformer("all-MiniLM-L6-v2")  # quick, small, effective
texts = [d["text"] for d in documents]

# 4 Encode
embeddings = model.encode(texts, show_progress_bar=True, convert_to_numpy=True)

# 5 Upload (batch)
points = []
for doc, emb in zip(documents, embeddings):
    points.append({
        "id": int(doc["id"]),
        "vector": emb.tolist(),
        "payload": {"text": doc["text"]}
    })
client.upsert(collection_name=collection_name, points=points)
print("Uploaded", len(points), "documents to Qdrant.")

• We used all-MiniLM-L6-v2 (384-dim) as a fast, small model suitable for demos; Sentence-Transformers offers many models depending on accuracy vs latency needs.

• A Qdrant collection was created Distance.COSINE to match cosine similarity, common for sentence embeddings.

D. Querying: similarity search

Append this to qdrant_semantic_search.py or run as a separate snippet:

query = "How do I speed up my Postgres database?"

q_emb = model.encode([query], convert_to_numpy=True)[0]
search_result = client.search(
    collection_name=collection_name,
    query_vector=q_emb.tolist(),
    limit=3,
    with_payload=True
)
for res in search_result:
    print(f"ID: {res.id} Score: {res.score:.4f}")
    print("Text:", res.payload.get("text"))
    print("---")

What to expect: The query about Postgres should return the Postgres performance document and possibly the vector-DB doc (if the embeddings put them closer). You can tune limit and score thresholds.

E. Optional: Improve relevance with reranking

Vector DB returns coarse candidates quickly; you can rerank the top-k using a dedicated cross-encoder or an LLM to get better ordering. This is common in production RAG pipelines (vector retrieval → reranker → LLM composition). Many tutorials (Qdrant and others) describe this pipeline pattern.

Performance tips, metrics, and monitoring (practical theory)

• Index parameter tuning: HNSW has parameters like ef_construction, m, ef (search param) that trade throughput and recall — tune them with real queries.

• Batch inserts: Bulk upload vectors to avoid per-point overhead.

• Memory & CPU: ANN indices are memory heavy; some DBs support disk-based IVF + PQ to lower memory at the cost of latency.

• Metrics to watch: QPS, P99 latency, recall@k, index build time, and RAM usage.

• Observability: Log query latencies and top-k recall vs. a small ground-truth set for automatic regression checks.

How to pick the right DB — a practical checklist

• Do you need managed serverless scaling? (→ Pinecone)

• Do you want open-source control and easy local dev? (→ Qdrant / Weaviate / Chroma)

• Already on Postgres and need ACID? (→ pgvector)

• Do you need hybrid search (keyword + semantic)? (→ Elasticsearch, Weaviate, others)

• Budget and infra: in-memory systems (Redis) are very fast but costly; Faiss + self-hosted can be cheaper but requires expertise.

What’s more to write now !!

Vector databases are the memory models of modern AI apps — they let your systems remember and understand meaning. Pick the right tool, measure results, and iterate. And hey — when your app starts recommending exactly what users want, resist the urge to whisper “I told you so” to your codebase.

Hope this blog clears some of your doubts about Vector Database. Thanks for reading this. Like, Share and Comment it for later reading.

Follow me on socials for more updates, behind-the-scenes work, and personal insights:

• Twitter

• Instagram

• Threads

Imagine ChatGPT but with access to your favorite bookmarks, PDFs, Slack threads, and weirdly named Google Docs you forgot existed. It’s like turning your AI into the friend who actually reads the group chat history before replying.

In practice, this means smarter, fresher, and far more context-aware responses. Think of an AI assistant that doesn’t just guess but double-checks its facts first (finally, some accountability in the relationship).

Below are 10 creative, beginner-friendly project ideas that combine LLMs with RAG — each with a memorable name, a pinch of purpose, and just the right amount of tech sauce.

So grab your favorite Python IDE (For me its VS code /Cursor), fire up your vector store, maybe even open up a Streamlit tab — and let your AI work overtime while your coffee gets cold.

Let’s dive in.

1. CodeWhisperer—Developer Documentation Chatbot

Tools & Technologies: PyPI (to load code/docs), LangChain or LlamaIndex (for document loaders and chains), FAISS or Chroma (vector store), GPT-4 / LLaMA-2 (LLM), and a simple front-end (Streamlit or a Slack bot).

Step-by-Step Design:

1. Collect docs: Scrape or download project documentation (e.g. Markdown files, API docs).

2. Preprocess: Split large files into ~500-token chunks and generate embeddings with an embedding model.

3. Index: Store all embeddings (with source pointers) in FAISS.

4. Query & Retrieve: When a user asks a code question, embed the query and find the top-matching doc chunks.

5. Generate: Pass those chunks plus the question to the LLM (via LangChain) to produce a clear answer or code snippet.

6. UI: Display the answer with highlights of source lines and allow follow-up queries.

Real-World Applications: Internal developer help desk (answering API questions), onboarding chatbots for coding projects, Slack or GitHub Copilot–style assistants. Bonus Upgrade Ideas: Add syntax-aware parsing so it can pull actual code examples, integrate with GitHub for live code lookup, or make a VS Code extension for in-IDE help.

2. LegalEagle—AI-Powered Contract Assistant

Need to know what that confusing contract clause really means? LegalEagle is a RAG chatbot for legal docs. It loads statutes, contracts, or case law and answers questions in plain English. By searching through real laws and rulings, it helps lawyers and paralegals find relevant information quickly. (RAG is great for law because it lets the AI search through case law and statutes rather than just.)

Tools & Technologies: Python (PyMuPDF or pdfplumber for PDFs), OpenAI/Anthropic LLM, Pinecone or Qdrant (vector DB), LangChain or Haystack, and a React or Streamlit front-end.

Step-by-Step Design Process:

1. Data Ingestion: Upload laws, regulations, or contracts (as PDFs or text).

2. Chunking & Embedding: Split into sections/paragraphs; create embeddings.

3. Indexing: Store embeddings in the vector DB with references to doc and page.

4. Semantic Search: On a query (e.g., “What are my rights under the privacy clause?”), find top matching chunks.

5. Answer Generation: Feed retrieved snippets to the LLM with a prompt like “Based on these excerpts, what does the contract say about X?”

6. UI & Interaction: Show the answer and the highlighted source text, and allow “ask follow-up” or download summaries.

Real-World Applications: Law firms or compliance teams searching internal policies, consumer legal Q&A chatbots, and contract review assistants.

Bonus Upgrade Ideas: Add filters by jurisdiction or date, support multiple languages (e.g., GDPR in English vs. original French), implement a feedback loop to refine answers, or integrate a knowledge graph for legal entities.

3. MediGuru — AI Medical Q&A Assistant

Imagine an AI that can quickly find medical advice from research papers (not a substitute for a doctor, but a very clever librarian for health info). MediGuru lets you ask questions like “What are the latest COPD treatments?” and it searches medical journals or guidelines to give an answer. Because healthcare knowledge changes fast, RAG is perfect here: the AI pulls fresh and relevant info from trusted source instead of outdated memory. It also tends to give more accurate, up-to-date answers when based on real data.

Tools & Technologies: LangChain (document loaders), Hugging Face/BioMed embedding model, a vector store (Chroma or Weaviate), OpenAI/GPT-4 or Claude (LLM), and a Streamlit or Flask interface.

Step-by-Step Design Process:

1. Gather Data: Pull abstracts/articles from PubMed, WHO, or hospital protocols.

2. Preprocess: Clean text, split into sections (e.g. “Diagnosis,” “Treatment”).

3. Embedding: Generate embeddings (BioBERT or OpenAI text-embedding).

4. Index: Store vectors in FAISS/Pinecone with doc links.

5. Query & Retrieve: User asks a medical question; system finds relevant passages.

6. Answering: LLM synthesizes an answer (with citations to source texts).

7. UI: Present answer + link to sources; include disclaimers and “ask doctor” follow-ups.

Real-World Applications: Hospital knowledge bases for doctors, patient symptom checkers (non-diagnostic), medical research assistants summarizing papers.

Bonus Upgrade Ideas: Enable citations (e.g. footnote journal names), fine-tune the LLM on medical Q&A, add symptom checker flows, or connect to wearable data (heart rate, etc.) for personalized tips.

4. LearnBot — Personalized Tutoring Assistant

Want a study buddy? LearnBot lets students chat with an AI tutor that pulls answers from textbooks and notes. For example, if you ask “Explain Newton’s second law,” it can retrieve definitions or examples from science texts instead of guessing. This means the answers are accurate and domain-specific (RAG systems are known to give higher accuracy and up-to-date responses.

Tools & Technologies: LangChain, open educational resources (Khan Academy, Wikipedia), VectorDB (Chroma), GPT-4 or a fine-tuned open LLM, and a chat UI (Discord bot or Streamlit).

Step-by-Step Design Process:

1. Load Learning Material: Ingest textbooks, lecture notes, or Q&A sets.

2. Chunk & Embed: Split chapters into bite-sized chunks, embed them.

3. Indexing: Store vectors in the database with topic labels.

4. Query: Student asks a question.

5. Semantic Retrieval: Find relevant passages (e.g. from algebra or history text).

6. Teaching Response: LLM crafts an explanation, quiz, or example problem, using the retrieved content.

7. Feedback Loop: Allow student to ask follow-ups or rate clarity.

Real-World Applications: Online tutoring services, homework help chatbots, language learning assistants.

Bonus Upgrade Ideas: Add multi-turn tutoring (track student progress in memory), generate practice quizzes, incorporate voice (so it reads answers aloud), or connect to an exam-prep database.

5. NewsDigest — News Summarizer & Q&A

Too many news sources, too little time? NewsDigest scans the latest articles, then uses RAG to summarize or answer questions. For instance, it could pull quotes from multiple news outlets to answer “What’s happening with the global economy?” By combining retrieval with generative AI, it delivers contextually rich summaries (RAG is shown to improve tasks like summarization and question.

Tools & Technologies: News API or RSS scrapers, text splitters, LangChain/Arxiv-lingua (for multi-language summarization), VectorDB (FAISS/Pinecone), GPT or an open-source LLM (for summarizing), and a web dashboard.

Step-by-Step Design Process:

1. Ingest News: Collect headlines/articles from RSS feeds or APIs.

2. Preprocess: Filter by date/keyword, clean HTML, chunk long articles.

3. Embedding: Create vectors for each chunk.

4. Indexing: Store embeddings chronologically.

5. Query & Retrieval: When asked a topic, fetch top related chunks from recent articles.

6. Generate Summary: LLM writes a concise summary or bulleted list of key points.

7. UI: Show the digest with links to source articles, allow subscription by topic or email.

Real-World Applications: News aggregation sites, market intelligence reports, daily briefing emails.

Bonus Upgrade Ideas: Add sentiment analysis (positive/negative news), trend charts (using retrieved data), fact-checking against official sources, or multilingual support.

6. TripPlanner AI — Smart Travel Itinerary Generator

Wish your AI friend could plan your vacation? TripPlanner AI asks for preferences (beach, budget, dates) and scrapes travel sites, then uses RAG to compile a day-by-day itinerary. For example, it might pull hotel info and local events from up-to-date sources. This is perfect for travel planning because it can fetch real-time data (weather, flight status, etc.) instead of outdated info.

Tools & Technologies: Web scrapers (for airlines, hotels, reviews), Google Maps API, LangChain (for query handling), VectorDB (Qdrant), GPT-4o (for natural language planning), and a React or mobile UI.

Step-by-Step Design Process:

1. Data Collection: Gather data on destinations (photos, attractions, transport) from TripAdvisor, Wikipedia, etc.

2. Preprocessing: Geotag information, chunk by location or theme.

3. Embeddings: Generate vectors for attractions, tips, reviews.

4. Index: Store vectors with geodata.

5. Query: User inputs “3-day London itinerary for families.”

6. Retrieval: Pull relevant descriptions (museums, parks, restaurants).

7. Answer Generation: LLM organizes them into a schedule with explanations. 8. UI: Display itinerary with maps and booking links.

Real-World Applications: Travel agency chatbots, vacation planning apps, voice assistants (e.g. Alexa skill).

Bonus Upgrade Ideas: Add integration with booking engines (flights, hotels), user ratings to refine suggestions, dynamic adjustment (if you stay longer, recompute), or AR features (point your camera and ask what’s nearby).

7. ShopAdvisor — E-Commerce Customer Assistant

Turn your product manuals and FAQ into a smart shopping assistant. ShopAdvisor lets customers ask questions like “Does this phone case fit the iPhone 14?” It then retrieves answers from product specs and reviews. In customer service, RAG pulls real product information and customer history to give tailored answers— much better than generic chatbot replies.

Tools & Technologies: VectorDB (Weaviate or Pinecone), LangChain (RetrieverQA chain), product catalog data (CSV or Shopify API), GPT-4o (LLM), and a web or chat interface (Zendesk/WhatsApp).

Step-by-Step Design Process:

1. Import Product Data: Load descriptions, manuals, spec sheets.

2. Text Splitting: Break specs/reviews into chunks.

3. Embedding: Create embeddings and index them.

4. Query: Customer asks a question about a product.

5. Search: Retrieve relevant chunks (images, text).

6. Answer & Explain: LLM composes the answer and can even quote the manual.

7. UI: Show answer plus links to product pages, let user “click to buy.”

Real-World Applications: Retail chatbots, automated FAQ pages, after-sales support (e.g. troubleshooting devices).

Bonus Upgrade Ideas: Add voice support (call center), translate Q&As for global customers, integrate customer account data for personalization, or upsell related products.

8. JobMate — AI Resume & Interview Coach

Get hired faster with an AI career coach. JobMate ingests job descriptions and career advice articles. When you ask “How do I tailor my resume for a data scientist role?”, it retrieves relevant tips (skills, keywords) and even drafts bullet points. It can also simulate interview questions by finding common ones for your field.

Tools & Technologies: Scraped data from Indeed/LinkedIn (job posts), StackOverflow (for technical Q&A), LangChain, FAISS, GPT (or an open interview-specific LLM), and a simple web app.

Step-by-Step Design Process:

1. Data Gathering: Collect sample job ads and successful resumes.

2. Preprocessing: Extract responsibilities and required skills.

3. Embedding: Vectorize job requirements and resume tips.

4. Indexing: Store embeddings.

5. Query: User inputs their profile and target role.

6. Retrieval: Find matching skills and keywords.

7. Generate: LLM suggests resume edits or common interview questions.

8. UI: Let user refine answers, export resume.

Real-World Applications: University career centers, job search platforms, talent coaching services.

Bonus Upgrade Ideas: Add live practice interviews (speech-to-text), connect to LinkedIn to auto-fill info, incorporate salary trends, or use reinforcement learning to rank the best resume phrasing.

9. BrainyBinder — Personal Knowledge Base

Build your own “Second Brain.” BrainyBinder takes your notes, PDFs, and bookmarks, then lets you query your personal archive. For example, you could ask, “What did I learn about neural networks in Q1?” and it will fetch answers from your saved docs. The AI essentially becomes your memorial librarian, combining all sources so it never forgets.

Tools & Technologies: LangChain or LlamaIndex (for various data loaders: Git, Google Docs, Markdown), a local vector store (Chroma or Qdrant), GPT-4o (LLM), and an Electron or web interface.

Step-by-Step Design Process:

1. Ingest Personal Files: Link Google Drive, Notion, or local folders.

2. Chunk & Embed: Process each document/note, generate embeddings.

3. Index: Keep a unified knowledge graph of all topics.

4. Query: User asks about something (project details, a past lecture, etc.).

5. Retrieve: Find the best-matching notes or emails.

6. Answer: LLM synthesizes a coherent summary or answer.

7. UI: Display answer with links to original notes; allow tagging or rating.

Real-World Applications: Researchers managing literature, students organizing study materials, professionals keeping track of meetings/ideas.

Bonus Upgrade Ideas: Semantic tagging and filtering (date, project), mobile sync (search on phone), proactive reminders (“You haven’t looked at this file in a month — summary?”), or multi-agent setup (one agent for each domain of knowledge).

10. ChefAI — Cooking & Recipe Assistant

Never wonder what’s for dinner again! ChefAI can chat about recipes and cooking tips. You point it to your favorite cookbooks or food blogs; then ask “What can I make with spinach and chickpeas?” It retrieves matching recipes and even suggests tweaks (gluten-free substitutes, spice levels).

Tools & Technologies: Recipes dataset (Kaggle or scraped sites), OpenAI embeddings or Sentence Transformers, LangChain (for QA chains), GPT-4o or a multilingual LLM (cooking terms), and a UI (mobile app or website).

Step-by-Step Design Process:

1. Collect Recipes: Scrape recipe sites or import a recipe book (structured with ingredients/instructions).

2. Preprocess: Normalize ingredients, split steps into sentences.

3. Embedding: Vectorize each ingredient list or step.

4. Index: Store in FAISS.

5. Query: User lists available ingredients or dish ideas.

6. Retrieve: Find similar recipes.

7. Generate: LLM suggests a recipe or adapts one (“Add more garlic,” etc.).

8. UI: Show recipe, nutritional info, and allow adjustments (servings, diet).

Real-World Applications: Smart kitchen assistants, diet planning apps, cooking chatbots for restaurants.

Bonus Upgrade Ideas: Integrate with voice assistants (Alexa, Google Home), add pantry tracking (reminds what you have left), generate shopping lists, or convert measurements automatically.

Each of these projects demonstrates how to combine an LLM with a retrieval system to create smarter AI apps. By grounding the model in real data (via RAG), you make it more useful and trustworthy. Pick one (or two!) that excites you, and start building — your portfolio will be proof that you can make AI that isn’t just clever, but also practical and fun for 2025–26.

If you are into Data Science, AI/ML and AI Engineering field. Don’t hesitate to build different types of projects. Always try to read and make projects. Work on fresh ideas. My funda is clear: Learn-> Build-> Show-> Get hired.

Thank you for reading this. Follow me here and on my socials for more such posts.

Follow me on socials:

• Twitter: https://x.com/techwith_ram

• LinkedIn:https://www.linkedin.com/in/ramakrushnamohapatra/

• Thread:https://www.threads.com/@techwith.ram

• Instagram:https://www.instagram.com/techwith.ram/

  ---

Share Growtechie

Artificial intelligence, especially large language models (LLMs), is now capable of writing and understanding code, generating complete applications, debugging, translating between languages, and more. Tools like GitHub Copilot and ChatGPT can whip up thousands of lines of code in seconds. So it’s fair to ask: Are we losing our golden ticket to job security?

The CEO of GitHub recently said that the future of programming is natural language.

What AI Can Do in Programming

• Generate code quickly: From CRUD apps to entire prototypes, AI can deliver.

• Translate languages: Need to convert JavaScript to Python? It’s a breeze.

• Create UIs: Front-end layouts and wireframes can be generated via prompt.

• Fix bugs: Minor issues can often be resolved without human help.

• Recognize patterns: AI excels at repetitive, pattern-driven tasks.

I once asked ChatGPT to build a Tinder-like dating app in Python. Within seconds, I had swiping logic, user profiles, and even a mock database. The only thing it didn’t do? Find me a date.

But AI Has Limitations

Despite its superpowers, AI has serious gaps:

• Lacks understanding of “why”: AI doesn’t know the business logic or the user context.

• Needs human judgment: Real-world problems need real-world intuition.

• Poor at prioritization: Long-term product thinking? Not its forte.

• Hallucinates: AI can confidently give you the wrong answer.

In fact, 55% of developers today use GitHub Copilot, but only 30% accept the suggestions without changes. That means if you’re not using AI, you’re behind. But if you always trust AI, you might be in deeper trouble.

Think of AI as a Brilliant Junior Developer

AI is fast, scalable, and tireless. But it doesn’t understand vision, empathy, or nuance. It can crank out solutions, but only we can decide if those solutions are correct, meaningful, and ethical.

The best software engineers don’t just write code. They:

• Understand user needs

• Collaborate across teams

• Make tough decisions

• Think strategically and ethically

The future software engineer isn’t just a coder—they’re a system thinker, a communicator, and a leader.

Will Software Engineers Lose Their Edge?

Absolutely not. If anything, the field is evolving to be more important:

1. We Understand AI Better

We know how AI models are built, where they fail, and how to guide them safely. That knowledge is vital in every modern product.

2. We Use AI More Effectively

AI can help anyone prototype a toy app, but production-grade systems need architecture, reliability, and scalability—still a human-led effort.

3. We Make AI Better

From fine-tuning LLMs to optimizing pipelines, engineers are the ones building, maintaining, and improving AI tools.

Remember: The CEO of GitHub said the future is natural language programming. But we’re still the ones building that future.

The Future Role of Software Engineers

In the AI era, software engineering expands beyond code:

• System Architects: Design intelligent systems that last.

• Ethical Technologists: Ensure tech aligns with human values.

• Creative Collaborators: Work with designers, marketers, and machines alike.

• AI Supervisors: Direct AI as a tool, not a replacement.

Just like designers can now prototype interfaces using prompts, and marketers can analyze data without engineers, the democratization of tools means engineers must rise to new challenges.

How to Prepare for a Future in AI-Driven Software Engineering

Master the Fundamentals

Algorithms, data structures, and programming principles still matter—deeply.

Learn System Design

Think like a senior engineer. Build software that scales and lasts.

Go Full Stack and Beyond

Know the full software lifecycle and cross disciplines: product, UX, data, and infra.

Communicate & Collaborate

People skills matter more than ever. Explain ideas. Lead teams. Solve real problems.

Use AI as a Creative Teammate

Prompt it. Debug with it. Brainstorm. Let AI handle the routine—you focus on vision.

Stay Adaptable

Languages and tools change. Learning how to learn is your real superpower.

We’re Not Just Coding the Future. We’re Leading It.

In an age when everyone can code a little, the ones who master software engineering will define the systems, tools, and societies of tomorrow. AI is raising the floor, but it’s up to us to raise the ceiling.

Software engineers will no longer just be programmers. They will be:

• Visionaries defining problems worth solving

• Bridgers connecting tools, teams, and disciplines

• Leaders guiding both humans and AI

The future won’t belong to those who code the fastest. It will belong to those who think deeply, adapt quickly, and build wisely.

And that golden ticket to job security?

It’s not lost.

It just changed form—and multiplied.

Follow me on socials:

• Twitter: https://x.com/techwith_ram

• LinkedIn:https://www.linkedin.com/in/ramakrushnamohapatra/

• Thread:https://www.threads.com/@techwith.ram

• Instagram:https://www.instagram.com/techwith.ram/

Share Growtechie's Newsletter

Every year, hackathons push the boundaries of what’s possible—and this time, the MIT AI Hackathon gave us a front-row seat to the future. From AI-powered rehab and recipe apps to wearables for the visually impaired, this event wasn’t just about flashy tech—it was about building real solutions for real human problems.

Let’s take a look at some of the standout projects—designed by students and makers across the world—that blend empathy, innovation, and artificial intelligence.

1. Rehab AI—Smarter Recovery at Home

Built by: Student, USA

Imagine doing your physical therapy sessions at home—and having an AI guide correct your posture, track your progress, and send feedback to your doctor in real time.

Rehab AI uses a phone or laptop camera, pose estimation models, and an LSTM neural network to monitor rehab exercises. It scores each movement and offers suggestions, making telerehab more accessible and precise—especially critical in the face of global healthcare worker shortages.

Why it matters: Home rehab can be lonely and error-prone. This app bridges the gap between patients and professionals.

2. Kidney Buddy—A Daily Companion for CKD Patients

Built by: Student, USA

Chronic Kidney Disease (CKD) patients need to track everything—from sodium intake to how they feel that day. Kidney Buddy is a friendly AI-powered assistant that simplifies this.

It offers meal planning, voice/text logging, nutrient tracking, and progress reports. Seniors were included in user testing, and doctors gave early feedback—making this more than just a student project; it’s something real patients could use.

Pro tip: It even helps you plan meals within your dietary restrictions.

3. Move to Heal—AI Rehab by High Schoolers

Built by: Students, Turkey

Yes, high schoolers built this! Move to Heal is an AI-based home rehabilitation platform with a focus on privacy-first pose tracking and real-time feedback.

It’s clean, simple, and empowering—especially for people with limited access to hospitals or physiotherapists. It also includes chatbot support and user-friendly progress tracking.

Next up: Clinical validation to roll it out in real-world scenarios.

4. Chook (ちょく)—The AI Chef That Cuts Food Waste

Built by: Student, Japan

Open your fridge. See random ingredients. Snap a photo. Let Chook tell you what to cook.

Inspired by a family’s struggle with food waste, Chook turns ordinary leftovers into creative meals. It’s fast, fun, and a small solution to a massive global problem—wasted food.

Built with love: It’s especially helpful for household cooks juggling busy days and limited ingredients.

5. Ikigai for Teens—Finding Purpose with AI

Built by: Students from various countries

What if teenagers could map out their dream career paths—not just by income, but by values, interests, and impact?

Ikigai for Teens is an AI-powered journaling and self-discovery app that does just that. Through voice notes and reflective prompts, teens can explore future careers, set goals, and develop confidence.

Why it’s brilliant: It focuses on who you want to be, not just what job pays the most.

6. Happy Food—Fighting Student Loneliness

Built by: Student, Japan

Not all students can attend school—some due to illness, anxiety, or family issues. Happy Food is an app that helps them connect with others in similar situations.

Students can chat securely, share experiences, and build friendships—fighting social isolation in a safe, peer-driven space.

Made for kids who feel alone when they shouldn’t have to be.

7. Vision Cap—Eyes Where There Are None

Built by: Adult, India

Imagine walking with confidence while being visually impaired. The Vision Cap is a hardware solution powered by Raspberry Pi and AI cameras that detects obstacles and provides voice alerts in real-time.

It includes features like caregiver monitoring, live video sharing, and personalized learning for the user’s environment.

This isn’t just assistive tech—it’s freedom.

8. Recycle Easy—Making Recycling Easy (and Fun)

Built by: Adult, Italy

Recycling shouldn’t be confusing. Recycle Easy uses a mobile app and IoT station to scan recycling codes, explain them, and direct you where to discard them based on your location.

To keep it fun, it includes gamified rewards and a memory game for kids about recycling materials.

Think Shazam meets Duolingo, but for trash.

9. Sleepfixer—Fixing the Sleep Crisis, One Night at a Time

Built by: Adult, Singapore

Sleep is broken for millions of people. Sleepfixer is here to help—with AI-generated gradual sleep shift plans, habit nudges, and progress tracking.

Whether you’re a night owl or recovering from jet lag, the app builds a personalized roadmap to fix your sleep schedule over time.

Bonus: no generic advice, just AI that adapts to you.

Small Teams, Big Visions

These aren’t just “projects”—they’re ”realsolutions to everyday challenges. What stood out most was the empathy and thoughtfulness behind each idea. Students involved their families. Adults partnered with local communities.

From AI for rehab and recycling to tools for loneliness, disability, and purpose—this MIT AI Hackathon reminded us that the best tech is deeply human.

Innovation doesn’t always need venture capital. Sometimes it just needs heart—and a hackathon.

Follow me on socials:

• Twitter: https://x.com/techwith_ram

• LinkedIn: https://www.linkedin.com/in/ramakrushnamohapatra/

• Thread: https://www.threads.com/@techwith.ram

• Instagram: https://www.instagram.com/techwith.ram/

Share Growtechie's Newsletter