The AI tooling ecosystem has a dependency problem. Here’s how I solved it.

If you use Cursor, Claude Code, or Codex seriously, you’ve probably done this: found a great collection of AI skills on GitHub, copied the files into your project, and congratulated yourself on a productivity upgrade.

Three weeks later, you open a new chat and wonder why the AI seems slower and vaguer than usual. You check the token count. Your context window is 60% full before you’ve typed a single word.

That was me. And it led me to build adt.

The Problem with Vendoring AI Skills

The standard advice for adding AI skills to your workflow is essentially “just copy the files.” Drop them in .cursor/rules/, or point Claude at a directory, and you’re done.

This works fine with five skills. It stops working when:

• You’re pulling from multiple upstream repos: Addy Osmani’s codebase safety rules, Matt Pocock’s shortcuts, Jesse Thorn’s superpowers…
• Those repos keep updating, and your copies go stale.
• You want to try a different set of skills for a different project.
• You work at a company that maintains their internal skills.

Every skill you vendor is loaded into context on every single chat. Most of the time, most of those skills are irrelevant to what you’re doing right now. You’re paying the context tax for all of them, all the time.

The deeper problem: there was no standard way to manage AI skills as dependencies. No install. No remove. No update. No list. Just cp -r.

What I Built

adt — AI Dev Toolkit — is an npm package that works like brew for AI tools.

npm install -g @saketananddotme/adt
adt init

That’s it. It detects your installed harnesses — Cursor, Claude Code, Codex — fetches a catalog of curated skill sources, and gets you set up in under a minute.

Then you install skills exactly how you’d install a package:

adt install obra # 14 skills from obra/superpowers
adt install addy/spec-driven-development # just one specific skill
adt install myteam # your team's internal skills

And remove them just as cleanly:

adt remove obra
adt uninstall # removes everything adt ever created

How It Works Under the Hood

Sources, Not Copies

Instead of copying skill files into your repo, adt clones the upstream Git repo into ~/.adt/sources/. It then creates individual symlinks from that clone into your harness directories: ~/.cursor/skills/, ~/.claude/skills/, and so on.

~/.adt/sources/obra/skills/brainstorming/ ← actual files
~/.cursor/skills/brainstorming ← symlink
~/.claude/skills/brainstorming ← symlink

The skills appear exactly where each AI tool expects them. Updating is just a git pull on the source — no manual copying ever again.

adt source update obra # pulls latest from upstream
adt update # updates all sources

The Manifest

The thing I’m most careful about: adt never touches files it didn’t create.

Every symlink is recorded in ~/.adt/.manifest.json. When you run adt remove or adt uninstall, it only removes entries from that manifest. Your own rules and skills are never at risk.

This was the failure mode of the alias approach I tried first:

# This DELETES your entire .cursor/rules directory
alias ai-addy="ln -sfn ~/.claude/skills/addyosmani/agent-skills .cursor/rules"

ln -sfn on a directory replaces the entire target. I learned this the hard way. The manifest-based approach means adt remove obra removes exactly the 17 things it installed, nothing else.

Auto-Discovery

adt doesn’t require any special configuration in your skill repo. It just looks for familiar conventions:

your-skills/
├── skills/    # dirs containing SKILL.md
├── agents/    # .md files
├── rules/     # .mdc files (Cursor only)
├── hooks/     # hook scripts
└── CLAUDE.md  # inserted as a marker block in ~/.claude/CLAUDE.md

Run adt source add yourname https://github.com/you/skills.git, and it clones, scans, and tells you what it found.

CLAUDE.md Without Clobbering

One tricky piece: Claude Code reads a ~/.claude/CLAUDE.md file as persistent memory. Multiple skill sources may all want to contribute to it. adt handles this with marker blocks:

<!-- ADT:obra:START -->
…obra's CLAUDE.md content…
<!-- ADT:obra:END -->

Each source gets its own block. Removing a source removes its block. If you manually edit inside a block, adt detects the change and asks before overwriting.

The Repo Split

Part of building this was realizing the original repo was trying to be too many things at once: the CLI tool, my personal skills, upstream skills from other people, all vendored together.

I split it into three:

RepoPurposesaketananddotme/ai-dev-toolkitThe adt CLI — 48KB, no dependenciessaketananddotme/ai-skillsMy personal skills, agents, and rulessaketananddotme/adt-catalogRemote catalog of curated sources

The CLI ships lean. Your skills live in your own repo, versioned separately. The catalog is community-maintained.

Try It

npm install -g @saketananddotme/adt
adt init
adt install obra
adt list --installed

Built-in sources to try:

• obra — obra/superpowers
• : rapid prototyping and agentic workflows
• addy — addyosmani/agent-skills
• : codebase safety
• matt — mattpocock/skills
• : daily debugging shortcuts

To add your own team’s skills:

adt source add myteam https://github.com/myteam/ai-skills.git
adt install myteam

The catalog is open for contributions at saketananddotme/adt-catalog

. If you maintain a skill collection worth sharing, open a PR.

The code is at github.com/saketananddotme/ai-dev-toolkit. Zero runtime dependencies, pure Node stdlib, ~650 lines.

Tags: AI, Developer Tools, Productivity, Claude, Cursor

How Cursor Works Under The Hood, Really Understands Your Code (and Why It Feels Like Magic)

If you’ve used Cursor for more than a few days, you’ve probably felt it.

• You ask “Where is auth handled?”
  → Cursor jumps straight to the right files.
• You ask “Show all usages of OrdersService”
  → It understands intent, not just text.

This isn’t autocomplete.
It isn’t just grep.

It’s Retrieval-Augmented Generation (RAG), built specifically for code.

• RAG in one line:
  Retrieve relevant chunks → add them to the prompt → generate the answer.
  The model never sees the whole repo, only what matters.

The Problem Cursor Is Solving

• Large repositories do not fit into an AI’s context window.
• Even the biggest models can’t read:
  • an entire monorepo
  • all services
  • configs
  • docs
• Trying to dump everything into context makes answers worse:
  • attention spreads thin
  • important details get lost in the middle
  • responses become vague or incorrect

Cursor avoids this entirely.

• Instead of asking “How do I show everything?”
• It asks:
  “What small pieces of this codebase matter right now?”

Step 1: Watching Your Code Without Uploading It

When you open a workspace, Cursor does not upload your codebase.

What it does instead:

• Builds a Merkle tree locally
• Every file gets a hash
• Every folder hash depends on its children
• Change one file → only one branch changes

This lets Cursor:

• detect exactly what changed
• sync only those changes
• avoid reprocessing the whole repo

Practical impact:

• In a 50,000-file repo, editing one file might sync only a few KB
• Your code stays local
• Sync stays fast

Step 2: Chunking Code the Right Way

Cursor does not split code by token count.

Instead:

• Uses tree-sitter, a real parser
• Understands syntax and structure

Chunks are:

• one function
• one class
• one logical block

Why this matters:

• Embeddings work better on meaningful units
• Functions describe intent
• Random text slices don’t

Edge cases:

• Very large or complex files may be skipped or partially indexed
• Tree-sitter can struggle with very large files (~32KB in some environments), so those get different handling

Step 3: Turning Code Into Meaning (Embeddings)

Each chunk becomes a vector embedding — numbers that represent meaning.

Important detail:

• This is not a generic text embedding
• Cursor trains its own code-specific embedding model

How it’s trained:

• Uses real agent sessions
• What people searched
• What files they opened
• What actually helped solve the task
• An LLM ranks “what would have been most helpful”
• The embedding model learns from those rankings

Result:

• Cursor learns how developers actually explore code
• Not just theoretical similarity

Efficiency:

• If a chunk hasn’t changed, the embedding is reused
• No wasted compute

Step 4: Privacy by Design

Before anything leaves your machine:

• File paths are obfuscated
• Directory structure is preserved, names are hidden
• Source code is never stored on Cursor servers

What is stored:

• embeddings
• metadata (encrypted paths, line ranges)

Even if someone accessed the vector DB:

• They would not see your code

Step 5: Where the Vectors Live (Turbopuffer)

Cursor stores embeddings in Turbopuffer, a high-throughput vector database.

Key ideas:

• Each (user_id, codebase) has its own namespace
• Active namespaces:
  - live in RAM / NVMe
  - fast (single-digit ms)
• Inactive namespaces:
  - move to object storage
  - cheap, slightly slower when reactivated

Result:

• Your current repo feels instant
• Old repos don’t waste memory

Index reuse with simhash

When two people in the same org open the same repo:

• Cursor computes a simhash from the Merkle tree
• Finds a teammate’s existing index
• Reuses embeddings instead of recomputing

Numbers that matter:

• Codebases in the same org are ~92% similar
• Time-to-first-query on large repos:
  • from 4+ hours
  • down to ~21 seconds

Privacy preserved:

• Client uploads its Merkle tree
• Server only returns results for code you actually have
• No cross-user leakage

Summary:

• Same code → same embeddings
• Different users → isolated namespaces

Step 6: When You Ask a Question

When you type:

“Where is user authentication handled?”

Cursor does all of this:

• Converts your question into an embedding
• Searches for similar code chunks
• Runs grep for exact matches
• Pulls in:
  • open files
  • semantic chunks
  • symbolic connections
  • lint
  • git history
  • docs
  • typing history

Total candidate context:

• Up to ~500k tokens

Hybrid search (why it feels precise)

Cursor uses both:

• Semantic search
  for intent (“where is auth handled?”)
• Grep
  for exact matches (“OrdersService”)

The agent:

• chooses which to use
• often combines them

This hybrid approach is a big reason Cursor feels so accurate.

Step 7: The Reranker (The Real Brain)

Cursor can’t send 500k tokens to an LLM.

So it uses a custom reranker:

• Scores all candidate context
• Filters it down to the most relevant ~8k tokens
• Selects, not compresses

Important:

• Context selection is still an open research problem
• Cursor keeps improving this layer

Step 8: Final Answer Generation

Only now does the LLM step in.

What it sees:

• just the right parts of your codebase
• not too much
• not too little

That’s why Cursor:

• explains existing code well
• answers “how does this work?” clearly
• scales to very large repositories

Why You Can’t “Doc the Whole Repo” in One Shot

Common request:

• “Generate documentation for the entire repo”

Why this fails:

• Context windows are finite
• Attention weakens as context grows
• Content in the middle gets ignored (“lost in the middle”)

Cursor avoids this by design:

• No single giant context
• Retrieval happens per question, per moment

That’s why it works.

Known Limitations

Cursor isn’t magic.

Things to know:

• Index refresh is about 5 minutes
• Recent edits may not be searchable yet
• Unsaved buffer edits aren’t indexed
  → Pro tip: save before asking, or use @ filename
• Query latency depends on cache:
  • warm: ~8–10ms
  • cold: ~500–600ms
• Generic queries can surface generic utility code
• Large or auto-generated files may be skipped
• Retrieval quality depends heavily on .cursorignore

Still, Cursor’s A/B tests show:

• ~12.5% higher accuracy on code questions
• ~2.6% better retention on large codebases (1,000+ files)
• ~2.2% fewer dissatisfied follow-ups

The gains are modest overall — but much larger where it matters: big repos.

Why This Feels So Good for Vibe Coding

Cursor doesn’t just search code.

It matches how developers think:

• jump between files
• follow call chains
• skim instead of reading everything
• ask fuzzy questions

It’s less like grep.

More like a very fast teammate who’s already explored the repo.

Learn to Use Cursor Better for Vibe Coding

In the next post, I’ll focus less on how Cursor works and more on how to use it well: prompts that work, common mistakes, and workflows that actually speed you up.

Follow if that sounds useful.

About Me: https://www.saketanand.me/

If you’re new to development, this might surprise you: developers spend a huge amount of time inside the terminal. If you’re a veteran, you already know the struggle 😄.

The terminal is our daily workbench. It’s where we run code, manage projects, install tools, and debug complex problems. But there is a recurring “tax” we all pay: The Setup.

Every time you get a new laptop or change your system, you have to set up the terminal all over again. It’s slow, boring, and repetitive.

The Problem: Manual Setup is Tedious (Especially for Beginners)

If you Google “best terminal setup,” you usually end up down a rabbit hole of manual steps:

• Installing Zsh
• Installing Oh My Zsh
• Finding a theme (like Powerlevel10k)
• Manually cloning plugins for suggestions and highlighting
• Editing hidden files like .zshrc (which is honestly scary the first time)

For beginners, this is confusing. For experienced developers, it’s just wasted time. Either way, it’s not how you want to spend your afternoon.

The Idea: One-Command Bootstrap

I wanted a world where I could open a fresh terminal, run one command, and have everything ready to go. No searching, no manual cloning, no mistakes.

That’s why I created awesome-terminal.

Now, I can go from a boring default terminal to a clean, powerful, and informative setup in seconds.

What’s Under the Hood?

The script doesn’t just “beautify” the shell; it adds intelligence to it. Here is what you get:

🧠 Oh My Zsh

The industry-standard framework that makes managing your Zsh configuration easy.

🎨 Powerlevel10k

The fastest and most flexible terminal theme available. It shows you exactly what you need — like your current Git branch or execution time — without any lag.

⚡ Productivity Plugins

• zsh-autosuggestions: Predicts your next command based on your history (huge time saver!).
• zsh-syntax-highlighting: Colors your commands so you spot typos before you hit Enter.
• you-should-use: A “coach” that reminds you of better aliases while you work.

🎛 The “Choice” Factor

During the setup, the script gives you a choice:

1. The Saket Setup: Use my pre-configured, ready-to-go layout.
2. The Fresh Start: Skip my config and let the Powerlevel10k wizard guide you through your own custom look.

How to Use It (Super Simple)

You don’t need to download anything manually. Just copy and paste this command into your terminal:

Bash

sh -c "$(curl -fsSL https://raw.githubusercontent.com/saketananddotme/awesome-terminal/main/setup.sh)"

That’s it. The script handles the rest.

Built for Developers, Not Just for Me

This project isn’t meant to be “my way or the highway.” It’s designed so you can own it.

Customize It (The Developer Way)

1. Fork the Repo: Go to the GitHub repo and click Fork. Now you have your own version.
2. Add Your Own Config: If you have a custom .p10k.zsh or favorite aliases, upload them to your repo and update the CONFIG_URL in setup.sh.
3. Change Plugins: Want docker, kubectl, or terraform support? Just edit the plugins=(...) line in the script.

Your Environment is Now “Cloud-Native”

Once it’s in your GitHub repo, your terminal setup is portable. Any laptop, any machine — one command and you’re home.

Why This Matters

As developers, we automate builds, tests, and deployments. We should also automate our environment. Forking and owning your setup lets you:

• Keep your terminal config in Version Control.
• Share a standardized setup with your team.
• Experiment safely and roll back if something breaks.

Your environment should be reproducible, just like your code.

Final Thoughts

As engineers, we should always look for ways to automate repetitive tasks. Setting up your environment shouldn’t be a chore.

Feel free to check out the repo, star it if it helps you, or even contribute to make it better!

Check out the project here: https://github.com/saketananddotme/awesome-terminal

If this helps you save time, feel free to ⭐ the repo!

Tags: Software Development, Productivity, Automation, Zsh, and Coding.

About Me: https://www.saketanand.me/

Why Use ESLint, Prettier, Husky, and lint-staged?

ESLint is a static code analysis tool that identifies problematic patterns in JavaScript code. It helps maintain code quality and enforce coding standards by highlighting syntax and style issues.

Prettier is an opinionated code formatter that supports many languages and integrates with most editors. It removes all original styling and ensures that all outputted code conforms to a consistent style.

Husky makes dealing with Git hooks easy. Git hooks are scripts that run automatically every time a particular event occurs in a Git repository. Husky allows you to use these hooks to run scripts before committing or pushing code, ensuring that your codebase remains error-free and adheres to your coding standards.

lint-staged runs linters on staged git files. This tool is beneficial in projects where you want to ensure that only files that are part of the commit are linted and formatted, making the commit process faster and more efficient.

Setting Up the Environment

Installation: Start by installing Husky, Prettier, ESLint, and lint-staged as development dependencies in your project. This ensures that these tools are available to everyone working on the project without needing global installation.

Husky is for git pre hooks (Hooks are something which runs on event)

npm install husky prettier eslint lint-staged — save-dev

Initialise ESLint and husky

npx eslint — init
npx husky install

### Package JSON

Make sure this is present in your `package.json`

”scripts”: { “prepare”: “husky install” }

Configure Prettier to format your staged file

“lint-staged”: {
“*.{js,jsx}”: [
“prettier — write”,
“eslint — fix”,
“git add”
],
“*.{html,css,less,ejs}”: [
“prettier — write”,
“git add”
]
}

ESLint Config

Create a file named `.eslintrc.js` in your root folder

module.exports = {
parser: ‘@typescript-eslint/parser’,
parserOptions: {
project: ‘tsconfig.json’,
tsconfigRootDir: __dirname,
sourceType: ‘module’,
},
plugins: [‘@typescript-eslint/eslint-plugin’],
extends: [
‘plugin:@typescript-eslint/recommended’,
‘plugin:prettier/recommended’,
],
root: true,
env: {
node: true,
jest: true,
},
ignorePatterns: [‘.eslintrc.js’],
rules: {
‘@typescript-eslint/interface-name-prefix’: ‘off’,
‘@typescript-eslint/explicit-function-return-type’: ‘off’,
‘@typescript-eslint/explicit-module-boundary-types’: ‘off’,
‘@typescript-eslint/no-explicit-any’: ‘off’,
},
};

Prettier Config

Create a filename `.prettierrc` in your root directory

{
“singleQuote”: true,
“trailingComma”: “all”
}

Initialise Husky

If you haven’t already, you need to initialise Husky in your project. This step is crucial because it sets up the necessary Git hooks in the `.husky/` directory. Depending on your Husky version, the command might differ. For Husky v4, the setup is included in the `package.json`. For Husky v5 and above, you need to run an initialisation command:

`npx husky install`

Setting Up Hooks with Newer Versions of Husky

If you’re using Husky v5 or above, the way to add hooks has changed from the configuration in `package.json` to creating hook files in the `.husky/` directory. For example, to add a `pre-push` hook, you would:

`npx husky add .husky/pre-push “npm test”`

or

`npx husky add .husky/pre-commit “npx lint-staged”`

You may choose to edit these files and add your new commands on a separate line

Ensure the Git Hooks are Executable

Make sure that the hook scripts in the `.husky/` directory are executable. You can change the permission of the hook scripts using the `chmod` command:

`chmod +x .husky/*`

Husky hooks might not run if there’s a local Git configuration overriding the hook path. You can check your current Git configuration for the `core.hooksPath` setting by running:

`git config — get core.hooksPath`

Benefits of This Setup

- Code Quality: Automatically ensures that your codebase adheres to defined coding standards and styles, reducing the time spent on code reviews.
- Efficiency: Catches and fixes errors early in the development process, significantly reducing the time and effort required for debugging and testing.
- Consistency: Enforces a consistent coding style across the entire codebase, making it easier to read and maintain.
- Automation: Automates repetitive tasks, allowing developers to focus on writing code rather than fixing styling or formatting issues.

By integrating ESLint, Prettier, Husky, and lint-staged into your development workflow, you create a robust environment that promotes writing high-quality code. This setup not only enhances productivity but also fosters a culture of collaboration and continuous improvement among development teams.

About Me: https://www.saketanand.me/

The One Card looks very attractive in the beginning but owing this is only results in financial loss and mental pressure. It is based on a concept. “Let people do something and we snatch their money”

In this post I will only explain charges of OneCard for the activity people mostly do in regular life. I am writing other blogs to make people aware of this company.

The joining fees for the metal card is FREE as they know that people will not pay 3000 for just a metal card.

Once you open an Credit card account with OneCard / OneScore, You can close the card by paying a total of 3000 + GST ( Approx 3500) within 6 months

If you ever lost this card, OneCard cost you around 3000 + GST (Approx 3500) to get a new card delivered to your home.

For EMI Transactions: Interest Rate is 29% annual on a reducing basis which is equivalent to 1.33 percent flat per month. They charge you 1% processing fees apart from interest and if you want to close your EMI loan then there is a 3% of foreclosure charge.

There is one more catch in EMI Transaction. Suppose, You purchased a iPhone latest model around 1 lac on Amazon/Flipkart with Metal OneCard / One Score Card on EMI. And after placing the order your mood changed and you wanted to cancel the order for any reason. Everyone knows that the Flipkart/Amazon doesn’t charge cancellation fee. But this Metal OneCard will charge you interest for 1 month around 1333 + 1% processing fee i.e 1000 rupees + GST which totals to be around Rs.3000.

When you will experience these you will try to close the card and then they will collect 3500 rupees for closure.

Credit card itself is money making product for banks, so a person should avoid using it unless very necessary. Still if you want to get a credit card, choose any bank like HDFC or ICICI. As per my knowledge ICICI also offers credit card on FD.

Be wise and avoid OneCard / OneScore / FPL Technologies as much as possible.

Where there’s a will there’s a way. The only thing you need to start programming is determination (and of course PC with Internet Connection). Every expert was once a beginner. The direction you go in will depend in large part on why you want to learn to code in the first place and how much time you have to devote to learning.

There is no one “best” programming language. If you are a beginner, you may start with Python as it is very easy to learn and also it is in high demand in market. Start with any good online video tutorial. I would suggest you to go with NPTEL (A project funded by MHRD. Govt of India). I have attached the link below.

NPTEL :: Computer Science and Engineering - NOC:The Joy of Computing using Python

After taking the tutorial, start reading the python docs. Go through https://docs.python.org/3/tutorial/index.html, if you want to dig deeper into the language read Library Reference and Language Reference respectively. These docs are going to help you a lot in polishing your skills.
Programming is not something you watch, read and learn, so you have to practice a lot. Start with writing small programs, Get some example question here.

Python Examples

Congratulations you have successfully written, compiled and run some programs, and this is called procedural / functional programming. You may want to learn intermediate concepts like Object Oriented Programming, Design Patterns etc. Python is in high demand now a days, It has various scope. If you are interested in website / web application you can start learning frameworks like Django, Flask, Pyramid, Bottle and Cherrypy. Or you may start courses on Machine Learning, Artificial Intelligence or Internet of Things.

You are about to become a programmer. And I promise you are going to love your skills. Your age doesn’t matter, your previous qualification doesn’t matter. Start learning today and I am always open to help you grow. If you need any guidance or support you can get my contact from the given link.

Official Website of Saket Anand

Thanks for spending your time to read this article. Good Luck.