<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Aman Kumar on Medium]]></title>
        <description><![CDATA[Stories by Aman Kumar on Medium]]></description>
        <link>https://medium.com/@onlyoneaman?source=rss-8a4500a23ecf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*GYH5jJJpthVv1gslVitwxg.jpeg</url>
            <title>Stories by Aman Kumar on Medium</title>
            <link>https://medium.com/@onlyoneaman?source=rss-8a4500a23ecf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 03:58:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@onlyoneaman/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Testing Jev on public and private data: classifier or filter?]]></title>
            <link>https://onlyoneaman.medium.com/testing-jev-on-public-and-private-data-classifier-or-filter-f617e2691008?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/f617e2691008</guid>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[classification]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 00:00:59 GMT</pubDate>
            <atom:updated>2026-09-18T07:51:22.399Z</atom:updated>
            <content:encoded><![CDATA[<h4>Jev only answers yes/no or pick-one. 16,000 calls: against gpt-5.4-mini and gpt-5.6-luna on four public datasets, and few thousand real pipeline decisions. Where it wins, where it breaks, how to use it.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2ARWgFTKXUNP-ItK" /></figure><p><a href="https://typesafe.ai/">TypeSafe</a> opened early access to <a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev">Jev</a> on 15 September. The headline numbers in the launch compare it with a frontier model writing text. Most teams do not run classification on a frontier model. The decisions a pipeline makes thousands of times a day (is this page worth reading, is this email a request, which bucket does this go in) mostly run on the small, fast tier already: flash-lite class models, gpt-5.4-mini, gpt-5.6-luna. That is the tier Jev has to beat, and the one I measured it against.</p><p>Jev is a model that does not write text. You give it some text and a question with fixed answers, and it gives back a probability for each answer. One call looks like this:</p><pre>POST https://api.typesafe.ai/v1/systemone<br>{<br>  &quot;model&quot;: &quot;jev-latest&quot;,<br>  &quot;state&quot;: {&quot;text&quot;: &quot;i am sorry that i was unable to get the full brunt of the comedy .&quot;},<br>  &quot;questions&quot;: {<br>    &quot;sentiment&quot;: {<br>      &quot;type&quot;: &quot;choice&quot;,<br>      &quot;instructions&quot;: &quot;Is this movie review positive or negative?&quot;,<br>      &quot;criteria&quot;: {&quot;negative&quot;: &quot;Unfavourable&quot;, &quot;positive&quot;: &quot;Favourable&quot;}<br>    }<br>  }<br>}</pre><pre>{<br>  &quot;answers&quot;: {<br>    &quot;sentiment&quot;: {<br>      &quot;choice&quot;: &quot;negative&quot;,<br>      &quot;probabilities&quot;: {&quot;negative&quot;: 0.97, &quot;positive&quot;: 0.03},<br>      &quot;confidence&quot;: 0.93<br>    }<br>  },<br>  &quot;usage&quot;: {&quot;input_tokens&quot;: 336},<br>  &quot;model&quot;: &quot;jev-1.13.0&quot;<br>}</pre><p>That call took 850 ms from my laptop and cost $0.000014: 336 input tokens at $0.042 per million, and output is free because there is none. A choice can have up to 255 options and comes back with a probability per option plus a confidence for the pick. A noul (TypeSafe&#39;s name for a yes/no question) comes back as one number, the probability of yes, so 0.05 is a confident no and 0.95 a confident yes. One call can carry many questions. TypeSafe does not say how confidence is computed; it is not the top probability (0.93 against 0.97 above), but gating on the top probability instead gave the same picture on the public sets, within a point. Confident, in this post, means that number was within 0.1 of either end for a yes/no, or 0.9 or higher for a pick-one.</p><p>I spent two days and about 16,000 calls finding out what it is good for. First on four public classification datasets, with two small OpenAI models answering the same questions. Then on a few thousand real decisions from the pipelines I work on, scored against what actually happened, not against another model’s opinion.</p><h3>TL;DR</h3><ul><li>On short-text classification it is level with or ahead of gpt-5.4-mini and gpt-5.6-luna on three of four public sets, at 5 to 56 times lower cost, with a median under a second.</li><li>Its probabilities hold near 0 and 1. On tasks it can do, confident answers were right 90 to 100% of the time; the middle is a coin flip.</li><li>It is best on short input with crisp labels. The longer the input and the fuzzier the labels, or the more business logic the question carries, the more its accuracy and its confidence fall together. On a whole-document read it is worse than the small model we run today, and no prompt fixed that.</li><li>So it is a filter, not a replacement. It takes the calls it is confident about at either end; the rest fall back to the model you already use.</li></ul><h3>Four public datasets</h3><p>300 random items from each of <a href="https://huggingface.co/datasets/SetFit/enron_spam">Enron spam</a>, <a href="https://huggingface.co/datasets/stanfordnlp/sst2">SST-2</a>, <a href="https://huggingface.co/datasets/fancyzhx/ag_news">AG News</a> and <a href="https://huggingface.co/datasets/legacy-datasets/banking77">Banking77</a>. Every model got the same question and the same one-line description per label, and had to return a probability for every option, because a gate needs that. The two OpenAI models ran through the Responses API with reasoning set to low; gpt-5.6-luna is one of the models on TypeSafe’s own eval board.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RxFpX9Tzuis_I_p_.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w9-5vMl-kUTArBrlC2bcTQ.png" /></figure><p>“When confident” is the pick-one sense: Jev’s confidence in its pick was 0.9 or higher. Jev took all 77 Banking77 options in one question without complaint; it is also the one set where both LLMs beat it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uuvXtaaTAASMMhiv.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MC0AS50AcwNt5MhENu5UHA.png" /></figure><p>Jev takes about the same time whatever the task. The LLMs get slower as the options grow, because they write a probability for each one. All of this was measured with 20 calls in flight, which is what a pipeline sees. Jev’s tail is not always this clean: at 100 calls in flight on our own pages a few per thousand took 10 to 35 seconds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-X9UXJzoxDpURHzH.png" /></figure><p>Two notes on cost. The LLM bills include output tokens, and asking for a probability per option is what makes them expensive: on Banking77 that is about 700 output tokens a call, which is why gpt-5.4-mini costs $3.81 per thousand there. Ask for the choice alone and the bill drops severalfold, but then there is no confidence to gate on. And the gap depends on what you compare against: 5 to 15× against gpt-5.6-luna, 100× and more against a model that reasons hard or an agent. More on that below.</p><p>Every case, every per-item answer from all three models, and the scoring code are at <a href="https://github.com/onlyoneaman/jev-eval">github.com/onlyoneaman/jev-eval</a>.</p><h3>On our own pipeline</h3><p>Public sets are a sanity check. What we cared about was whether Jev could replace any of the classifier work we run today, thousands of small decisions a week. For these the answer key is what happened afterwards: did the page produce anything, did a human keep the task the agent started.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NfcIA_QzXAAf7nVeHoabqg.png" /></figure><p><em>Agrees with the outcome: Jev’s yes/no, cutting P(yes) at 0.5, against what happened afterwards (the routing row is checked against today’s classifier, since those pages have no outcome of their own). Accurate when confident: accuracy where P(yes) was at or below 0.1 or at or above 0.9, and the share of items in that band, which on pages is mostly the low end.</em></p><p>The simple page types are where it earns its keep. It matched the outcome 96 to 98% of the time, matched our existing classifier 95 to 97%, and its probabilities barely move: the same page asked twice differs by about 0.01. It went in front of the classifier as a reject filter: any page with a P(yes) under the threshold (set as described below) skips the model, everything else goes through as before. Replaying five production runs with the filter off and on gave the same output on all 1,005 pages, with 50 to 67% fewer routing calls, 45 to 74% fewer admin-page calls and 8 to 13% fewer locations calls, the last one smaller because the classifier reads pages in pairs and a pair is only skipped when both pages are under the line.</p><p>The hard page type is where it does not. “Does this page carry a value for one of 135 report rows” means telling apart a mention of something from an actual value for it, and Jev fires on the mention. It needed about twice as many extraction jobs to match our recall, and its probability swung by 0.5 between runs on the same page. A general LLM asked the same question failed the same way, so this is the task, not the model.</p><p>The inbox was the most interesting. Today every mail on a shared service inbox gets an agent session that decides whether it is a request we should work on; that costs about 12 cents and 94 seconds at the median, and most of the time the answer is no. Given the same mail and the same written rules, Jev matched the recorded outcome 87% of the time, and 96% on the mail it was confident about (69% of it). But a few genuine requests come back near zero, a confident no (a routine request that happens to name a third party reads to it like a policy change), so there is no lossless threshold. What it offers is a trade: drop everything under 0.03 and 78% of the non-requests disappear, at the cost of 5 of the 231 real requests in this set. Those five are mostly short forwards from colleagues and mail whose only evidence is a photo, which Jev cannot read; route those two kinds to the agent regardless and what is left loses about one request in 140.</p><h3>What each decision costs us today</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WEnakw6iFopr0EThvH1BmQ.png" /></figure><p>On the document pipeline the saving is modest in dollars, a few percent of a run, and large in call volume: about a quarter of all calls to that rate-limited provider go away. On the inbox it is the reverse: few calls, but each one is an agent session, so the dollars are the point.</p><h3>Trust the ends, not the middle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*veeKm5VNYuQZRjYZ.png" /></figure><p>The useful thing about the number is that the ends mean what they say. On the public sets, 82% of the answers came back with confidence 0.9 or higher and 96% of those were correct; below 0.9 it was right 55 to 72% of the time depending on the band. On our pages the number is P(yes), so the two ends are a confident no and a confident yes, and both hold: 82% of pages came back under 0.1 and 0.3% of those turned out to matter; the 4% at 0.9 and above mattered 97% of the time; the 14% in between run from 6% to 83% depending on the band. No single cut-off works there. So trust the ends, and hand the middle to a model that can actually read the thing. (The page panel pools the three gates, 2,559 calls, because the routing gate contributes only the 549 pages that have an outcome of their own.)</p><p>You do not pick the drop threshold by hand. Take every item you know was a real positive, find the lowest P(yes) Jev gave any of them, and put the line at half of that. Set it on part of your data, check it on the rest, and re-check as new data arrives, because next month can bring a real positive lower than any you have seen. On our gates I set it on four of the five production runs and checked it on the fifth, rotating, and no fold lost a page. The lines came out at 0.12, 0.065 and 0.025 for routing, admin and locations, from 187, 124 and 61 positives, and put 25 to 60% of pages under the line. The line comes from your positives, not from the confident band, so it can land on either side of 0.1. On email it put almost nothing under the line, so there is no useful lossless threshold there, only the trade above.</p><h3>100× cheaper than what?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jOpK3OxVqIzHkuKb1E0NAg.png" /></figure><p>An LLM’s output tokens cost 4 to 8 times its input tokens, and with reasoning on, most of its tokens are thinking. Jev has no output tokens. Keep reasoning low and the answer to a few tokens, and most of the headline gap disappears; what is left is the cheaper input price and a single pass.</p><h3>What others are seeing</h3><p>Three days in, most of the noise is reaction to the announcement. The <a href="https://news.ycombinator.com/item?id=49717558">Hacker News thread</a> is near 500 comments and very few are from people who had called the API. The argument there is about framing: the 193× and 444× headline compares Jev with a frontier model writing its answer out as text; “cannot hallucinate” means the output is typed, not that it is right; and <a href="https://evals.typesafe.ai/">TypeSafe’s own eval board</a> grades against the average of GPT-6 Astra and Claude Fable 5.1 rather than ground truth, where Jev sits at 67.8% against 74.1% for the best LLM, never top on accuracy, 200× cheaper. When a commenter called it “basically a zero-shot classifier”, the <a href="https://news.ycombinator.com/item?id=49718727">CEO replied “exactly right”</a>, which is the most useful sentence in the thread. Within two days there were open imitations on GitHub and Hugging Face and a <a href="https://github.com/AnotiaWang/awesome-jev">70-repo awesome list</a>.</p><p>The measured reports, where someone ran Jev against an LLM on the same task, split by the shape of the task.</p><p>Short input, crisp labels: it wins or ties. <a href="https://nearhere.events/blog/typesafe-jev-mistral-gemini-event-validation">Near Here</a> ran event listings against Mistral Small 4 and Gemini 3.5 Flash-Lite on high reasoning: 48 of 50 to their 42 and 43, none of the 13 real events rejected, 0.6 s against 2.9 and 3.4 s, 4¢ per thousand against 37¢ and $2.50. Vercel’s CTO <a href="https://x.com/cramforce/status/2100269198727602468">ran it on an existing classifier eval</a> that used Gemini 2.5 Flash Lite and it “won both on quality (saturated the eval) and speed (6x)”. <a href="https://x.com/h_nilforoshan/status/2100411132498641301">HiringCafe</a> scores resumes against job descriptions with human labels: Spearman 0.79 at 2¢ per thousand, against 0.77 for DeepSeek V4 Flash at 14¢ and 0.72 for Gemini 3.1 Flash-Lite at 29¢. <a href="https://github.com/bitnovus/jev-spam-eval">A 19,500-email spam run</a> got 98.3% zero-shot, level with a logistic regression trained on 15,000 of those emails, and its calibration matches mine: 0.1% spam below 0.1, 99.9% at 0.9 and above, 38% in the 0.5 to 0.6 band. <a href="https://dev.classmethod.jp/en/articles/jev-for-llm-model-routing/">Classmethod</a>’s model router: 40 of 40 at 2.5¢ per thousand, lower confidence in the middle tier. <a href="https://every.to/also-true-for-humans/mini-vibe-check-typesafe-s-jev-judged-everything-i-ve-written-in-0-7-seconds">Every</a>: 6 of 7 planted defects at 0.35 s a passage, where Claude Fable 5.1 caught 7 at 8.8 s.</p><p>Longer input, fuzzier labels, or a verdict that needs reasoning: it loses, and the fix is the same each time. <a href="https://github.com/anisselbd/jev-phishing-bench">A 2,000-email phishing bench</a> had Jev at 62.6% against 81.3% for Claude Haiku 4.5, with worse calibration and a 5-point swing from question wording alone; five narrow yes/no signals plus a logistic regression reached 95%, and Haiku on the same five signals got 93%. <a href="https://github.com/SamuelSacco/jev-exploration">Samuel Sacco</a>’s 800-item difficulty ladder found the probabilities overstate the low end and understate the high end, yet everything at 0.9 or above was right, on 21 to 32% of items; his advice, treat the number as a score and fit your own cut-offs on a few hundred labelled cases, is where I landed too. <a href="https://backnotprop.com/blog/jev-poker/">A poker study</a> against a solver: 63% on random spots, 94% on easy ones. And TypeSafe’s weakest workflow on its own board is invoice processing, 61.8% against 79.1%, the same kind of whole-document read where it failed for me.</p><h3>Verdict</h3><p>Filter. Jev is cheap and fast, answers only yes/no and pick-one questions, and its probability means what it says at the ends. That is enough to put it in front of a classifier and not enough to put it in place of one.</p><p>Below the drop line it was never wrong on our data, so those items skip the classifier and nothing downstream changes; on our page gates that was 25 to 60% of pages. Above 0.9 it is right 97% of the time on our pages and 90 to 99.6% on every public set, so where most items land up there you can act on Jev’s answer and never call the classifier at all. We did not need that on pages, where only 3 to 9% land that high, but on a spam gate it is the bigger end: on Enron, 90% of items sit at 0.9 or above with 99.6% accuracy, nine classifier calls in ten gone. Everything in between falls back to the model you already use, exactly as today.</p><p>The pattern held in every test, mine and other people’s. Short input, crisp labels: near-perfect and confident. Long input, fuzzy labels, or a rule that needs reasoning: accuracy and confidence fall together, and the fix is to split the question into narrow yes/no signals and combine them in code, which took the phishing bench from 63% to 95%.</p><p>That ceiling is the thing to watch. Everything Jev gets wrong here is a long-input problem, and <a href="https://docs.typesafe.ai/model-jaggedness/jev-1.13">TypeSafe’s own notes</a> say accuracy falls as the state grows. If a later version holds up on a full page or a full thread the way this one holds up on a sentence, the filter becomes the classifier, even for the complex ones, and the fallback becomes the exception.</p><p>Set both lines on your own recorded outcomes, check them on data you did not use to set them, and never ask it anything that needs the whole document read before the answer exists. The title’s question has a one-word answer; the work is in where you draw the two lines.</p><p><em>The public half is in the repo above, down to every per-item answer; the pipeline numbers are from our own production code and data.</em></p><p><em>Originally published at </em><a href="https://amankumar.ai/blogs/jev-measured"><em>https://amankumar.ai</em></a><em> on September 18, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f617e2691008" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Setting Up Mac for Development [May 2026]]]></title>
            <link>https://medium.com/macoclock/setting-up-mac-for-development-may-2026-b6b456efd823?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6b456efd823</guid>
            <category><![CDATA[tools]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[mac]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Wed, 20 May 2026 19:56:18 GMT</pubDate>
            <atom:updated>2026-05-26T19:30:27.277Z</atom:updated>
            <content:encoded><![CDATA[<h4>The current toolkit and the AI coding stack I’d put on a fresh Mac today. A year after my 2025 setup.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*EKNIYRxqTsFim72V" /></figure><p>Mostly on a MacBook Pro now, with a Mac Mini (M4, 16GB, 512GB) at the desk. Very different setup from 2025.</p><p>A year is a long time in 2026. The AI coding tools I was running in May 2025 are mostly gone from my dock. Here’s the toolkit I’d put on a fresh Mac today.</p><h3>🧰 Core tools</h3><ul><li><a href="https://brew.sh/"><strong>Homebrew</strong></a>. Still the package manager for everything.</li><li><strong>zsh + </strong><a href="https://ohmyz.sh/"><strong>oh-my-zsh</strong></a>. Config stays small; fast startup matters.</li><li><a href="https://iterm2.com/"><strong>iTerm2</strong></a>. Still my daily terminal. <a href="https://ghostty.org/">Ghostty</a> is on the list to try.</li><li><a href="https://github.com/Schniz/fnm"><strong>fnm</strong></a>. Rust-based Node version manager. Drop-in replacement for nvm, ~10x faster shell startup.</li><li><a href="https://bun.sh/"><strong>bun</strong></a> for anything where Node feels slow.</li><li><a href="https://docs.astral.sh/uv/"><strong>uv</strong></a>. Python package and project manager. Quietly replaced pip and virtualenv for me.</li><li><a href="https://github.com/pyenv/pyenv"><strong>pyenv</strong></a>. Kept around for legacy Python projects.</li></ul><h3>🤖 The 2026 AI coding stack</h3><p>This is the section that aged fastest from the 2025 post, so it gets the most attention.</p><p>I used <a href="https://windsurf.com/">Windsurf</a> for about 5 months, then <a href="https://cursor.com/">Cursor</a> for another 5 or 6. Both were good. Both got replaced once terminal-native agents got good enough. Today I use three:</p><ul><li><a href="https://openai.com/codex"><strong>Codex</strong></a> for long, delegated work. Parallel worktrees, multiple agents on different branches, while I do something else. Best when I want to come back to a finished result and review it.</li><li><a href="https://claude.com/claude-code"><strong>Claude Code</strong></a> is my default for anything I want to stay in the loop on. Lives in the repo, plays well with MCP servers, fits the “agent operating inside my project” mode.</li><li><a href="https://antigravity.google/"><strong>Antigravity</strong></a>. I open it sometimes as an IDE to <em>see</em> the code an agent produced, scroll the diff, or make a focused manual edit. Not my daily editor.</li></ul><p>Setting up a Mac today and only want to install one? Start with Claude Code.</p><h3>📦 Daily drivers</h3><ul><li><a href="https://www.raycast.com/"><strong>Raycast</strong></a>. Launcher and snippet expansion. The thing I open most after the browser.</li><li><a href="https://rectangleapp.com/"><strong>Rectangle</strong></a>. Window snapping.</li><li><a href="https://github.com/TermiT/Flycut"><strong>Flycut</strong></a>. Clipboard manager.</li><li><a href="https://code.visualstudio.com/"><strong>VS Code</strong></a>. Plain editor when I don’t want an agent in the way.</li><li><a href="https://wisprflow.ai/"><strong>Wispr Flow</strong></a>. Voice-to-text everywhere. Faster than typing for messages and prompts.</li><li><a href="https://www.notion.so/"><strong>Notion</strong></a>. Work and personal notes.</li><li><a href="https://tailscale.com/"><strong>Tailscale</strong></a>. Private mesh between my machines.</li><li><a href="https://www.google.com/chrome/"><strong>Chrome</strong></a>. Default browser.</li><li><a href="https://slack.com/"><strong>Slack</strong></a>, <a href="https://discord.com/"><strong>Discord</strong></a>, <a href="https://www.whatsapp.com/"><strong>WhatsApp</strong></a> for comms.</li><li><a href="https://www.figma.com/"><strong>Figma</strong></a>. Design and the occasional spec.</li><li><a href="https://www.spotify.com/"><strong>Spotify</strong></a> for music.</li></ul><h3>⚙️ CLI toolbelt</h3><p>Stuff I install on every machine and then forget I’m using:</p><pre>brew install gh ripgrep tmux tig htop jq pandoc \<br>  ffmpeg imagemagick whisper-cpp nmap ngrok \<br>  stripe cloudflare-wrangler render asc gemini-cli</pre><ul><li>gh for GitHub from the terminal.</li><li>rg for search. Replaced grep in my muscle memory.</li><li>tmux, tig for sessions and a sane Git browser.</li><li>whisper-cpp for local transcription.</li><li>Cloud CLIs (wrangler, render, stripe, asc, etc.). Install the ones you actually deploy to.</li></ul><h3>🧠 Personal shell ergonomics</h3><p>A few aliases and functions from my .zshrc that pull their weight:</p><pre># Project jumps<br>alias pj=&quot;cd ~/projects&quot;<br><br># npm shortcuts<br>alias nd=&quot;npm run dev&quot;<br>alias nb=&quot;npm run build&quot;<br>alias ni=&quot;npm install&quot;<br><br># Claude Code, too useful to type out<br>alias c=&quot;claude&quot;<br>alias cladue=&quot;claude&quot;   # because I mistype it constantly<br><br># Quick git worktree on a new branch<br>wt() {<br>  local branch=&quot;$1&quot;<br>  local dir=&quot;../$(basename &quot;$PWD&quot;)__${branch//\//-}&quot;<br>  git worktree add -b &quot;$branch&quot; &quot;$dir&quot; &amp;&amp; cd &quot;$dir&quot;<br>}</pre><p>The wt helper became essential once I started running multiple agents in parallel. Each one gets its own worktree.</p><h3>🧷 System tweaks</h3><p>Faster keyboard repeat:</p><pre>defaults write -g InitialKeyRepeat -int 15<br>defaults write -g KeyRepeat -int 1</pre><p>Disable auto-correct (it fights you in the terminal):</p><pre>defaults write -g NSAutomaticSpellingCorrectionEnabled -bool false</pre><h3>🗝 Bonus setup</h3><p><strong>Xcode Command Line Tools</strong> (Git, compilers, etc.):</p><pre>xcode-select --install</pre><p><strong>Git identity:</strong></p><pre>git config --global user.name &quot;Your Name&quot;<br>git config --global user.email &quot;you@example.com&quot;</pre><p><strong>SSH key for GitHub:</strong></p><pre>ssh-keygen -t ed25519 -C &quot;you@example.com&quot;<br>pbcopy &lt; ~/.ssh/id_ed25519.pub</pre><p><strong>Claude Code with MCP servers.</strong> Once Claude Code is installed, wire up the MCP servers you actually use (Linear, GitHub, Playwright, etc.).</p><p><strong>Project folder:</strong></p><pre>mkdir ~/projects</pre><h3>📚 Resources</h3><ul><li><a href="https://amankumar.ai/blogs/setup-new-mac-tools">Setting Up Mac for Development (2025)</a> (previous edition)</li><li><a href="https://amankumar.ai/blogs/zsh-aliases-productivity">ZSH Aliases for Productivity</a></li><li><a href="https://github.com/Schniz/fnm">fnm</a> · <a href="https://github.com/astral-sh/uv">uv</a> · <a href="https://www.raycast.com/">Raycast</a></li><li><a href="https://claude.com/claude-code">Claude Code</a> · <a href="https://openai.com/codex">Codex</a> · <a href="https://antigravity.google/">Antigravity</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6b456efd823" width="1" height="1" alt=""><hr><p><a href="https://medium.com/macoclock/setting-up-mac-for-development-may-2026-b6b456efd823">Setting Up Mac for Development [May 2026]</a> was originally published in <a href="https://medium.com/macoclock">Mac O’Clock</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Embeddings: Turning Meaning Into Geometry]]></title>
            <link>https://onlyoneaman.medium.com/embeddings-turning-meaning-into-geometry-6e1c548efe06?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e1c548efe06</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[vector-database]]></category>
            <category><![CDATA[gpt]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Tue, 06 Jan 2026 15:29:26 GMT</pubDate>
            <atom:updated>2026-01-06T15:29:26.951Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A practical mental model for understanding embeddings, how they work, and why they matter for AI engineers</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*iItV6gXi0PjUqQ0j" /></figure><p><em>This is Part 1 of a 4-part series on embeddings. </em><a href="https://amankumar.ai/blogs/embeddings-part-2"><em>Part 2: How Embeddings Actually Work in Practice</em></a><em> | </em><a href="https://amankumar.ai/blogs/embeddings-part-3"><em>Part 3: Retrieval Is Not Top-K</em></a><em> | </em><a href="https://amankumar.ai/blogs/embeddings-part-4"><em>Part 4: From Retrieved Context to a Grounded Answer</em></a></p><p>A practical mental model for beginners and AI engineers</p><h3>A small story to start</h3><p>You have 100,000 documents.<br>A user types a simple question:</p><blockquote>How do I cancel my policy?</blockquote><p>You run a keyword search.<br>Nothing useful comes back.</p><p>You try again:</p><ul><li>terminate policy</li><li>end coverage</li><li>close insurance</li></ul><p>Some results appear. Many are irrelevant. Some are outdated. Some obvious matches are missing.</p><p>The problem is not search.</p><p>The problem is that computers do not know when two things <strong>mean</strong> the same thing.</p><p>This is the problem embeddings were created to solve.</p><h3>The core problem embeddings exist for</h3><p>Computers work well with:</p><ul><li><em>Numbers</em></li><li><em>Exact strings</em></li><li><em>Fixed rules</em></li></ul><p>Humans communicate with:</p><ul><li>Meaning</li><li>Context</li><li>Approximation</li></ul><p>When a human sees these two sentences:</p><ul><li>How do I cancel my insurance?</li><li>How can I end my policy?</li></ul><p>They immediately know they are asking the same thing.</p><p>To a computer, these are just different strings.</p><p>So instead of asking:</p><blockquote>Are these two texts equal?</blockquote><p>We ask a different question:</p><blockquote>Can we represent meaning in a way that makes similar things comparable?</blockquote><p>Embeddings are the answer to that question.</p><h3>What an embedding actually is</h3><p>At its simplest:</p><blockquote>An embedding is a list of numbers that represents an object.</blockquote><p>That object can be:</p><ul><li>A sentence</li><li>A paragraph</li><li>A document</li><li>An image</li><li>A user</li><li>A product</li></ul><p>The key property is this:</p><blockquote>If two embeddings are close together, the things they represent are likely similar in meaning.</blockquote><h3>A simple example</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IjPiZHB23Xdydfyz8KM_RA.png" /></figure><p>That is all an embedding promises.</p><p>Not understanding. Not correctness. Just proximity.</p><h3>Why vectors and not keywords or labels</h3><p>Keywords break when wording changes.<br>Labels require humans and do not scale.<br>Rules become brittle and complex.<br>Vectors give you something much simpler and more powerful: <strong>distance</strong>.</p><p>With vectors, you can:</p><ul><li>Measure similarity</li><li>Find nearest neighbors</li><li>Form clusters</li><li>Compare many items efficiently</li></ul><p>A useful analogy is a map.</p><p>Two cities being close on a map does not mean they are the same city. It means traveling between them is easy.</p><p>Embeddings are maps of meaning, not definitions.</p><h3>The famous king–queen analogy (explained properly)</h3><p>You may have seen this example before:</p><blockquote>king − man + woman ≈ queen</blockquote><p>This is not magic. It is geometry.</p><h4>What is actually happening</h4><p>Embedding models learn <strong>relationships</strong>, not facts.</p><p>They notice patterns like:</p><ul><li>king and queen are related</li><li>man and woman are related</li><li>gender differences form a direction in vector space</li></ul><p>So when you subtract one relationship and add another, you often land near a related concept.</p><h4>Visual intuition</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i3HOjhba6YUG0dPiU-T_UQ.png" /></figure><p>When you do:</p><blockquote>king − man → mostly royalty<br>royalty + woman → queen</blockquote><p>Important clarification:</p><blockquote>This works because the model learned consistent patterns across large data. It is not reasoning. It is alignment.</blockquote><p>And it does not always work.</p><h4>How embeddings are learned (without math)</h4><p>Embedding models are trained on massive datasets where relationships exist.</p><p>They see:</p><ul><li>Things that appear together</li><li>Things that appear in similar contexts</li><li>Things that rarely appear together</li></ul><p>The training goal is simple:</p><blockquote>Put related things closer together. Push unrelated things farther apart.</blockquote><p>One critical idea to understand:</p><blockquote>Embeddings are not trained to be correct. They are trained to be useful for certain tasks.</blockquote><p>This explains:</p><ul><li>Why different models behave differently</li><li>Why embeddings shift across domains</li><li>Why there is no single “true” embedding for a sentence</li></ul><h3>What embeddings unlock in practice</h3><p>Once meaning becomes geometry, many problems become easier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NzURi2WW0mU0v1Vkgt2Ajg.png" /></figure><p>A good summary:</p><blockquote>Embeddings turn unstructured problems into geometric ones.</blockquote><h4>What embeddings are not</h4><p>This is where most misunderstandings begin.</p><p>Embeddings are <strong>not</strong>:</p><ul><li>Memory</li><li>A database</li><li>A source of truth</li><li>Interpretable</li><li>Stable forever</li></ul><h4>A practical failure example</h4><p>Two documents are almost identical:</p><ul><li>One is an outdated policy</li><li>One is the current policy</li></ul><p>Their embeddings will be very close.</p><p>The embedding does not know which one is correct.</p><p>Closeness means similar, not correct.</p><p>This distinction matters later when systems fail in production.</p><h4>Why embeddings still matter with large language models</h4><p>Large language models can reason and generate text.</p><p>They cannot cheaply scan your entire private corpus and decide what matters.</p><p>You still need a way to <strong>select</strong> information.</p><p>Embeddings do that selection.</p><p>A useful mental model:</p><blockquote>Embeddings decide what the model sees. The language model decides what the model says.</blockquote><p>Or:</p><blockquote>Embeddings are the librarian. The LLM is the author.</blockquote><p>Without the librarian, the author is guessing.</p><h4>The mental model to keep</h4><p>If you remember one thing, remember this:</p><blockquote>Embeddings are lossy compression for meaning, designed for retrieval and routing.</blockquote><p>They trade:</p><ul><li>Precision for scale</li><li>Truth for usefulness</li><li>Accuracy for speed</li></ul><p>They are infrastructure, not intelligence.</p><p>Once you see embeddings this way, their strengths and limitations become clear.</p><h3>What comes next</h3><p>If embeddings are this simple, an obvious question follows:</p><blockquote>Why do they fail so often in real systems?</blockquote><p>The answer has very little to do with models, and a lot to do with how we use them.</p><p>Most failures come from configuration, not the embedding model itself. <a href="https://amankumar.ai/blogs/embeddings-part-2">Part 2</a> covers the practical decisions that determine whether retrieval works: chunking strategies, dimension selection, and how meaning gets broken before it ever reaches the embedding model.</p><p>Thanks for reading. If you found this useful, you can follow or connect with me here: <a href="https://x.com/onlyoneaman/">x.com</a> <a href="https://www.linkedin.com/in/onlyoneaman/">linkedin</a></p><p><strong>Next:</strong> <a href="https://amankumar.ai/blogs/embeddings-part-2">Part 2: How Embeddings Actually Work in Practice</a> → <a href="https://amankumar.ai/blogs/embeddings-part-3">Part 3: Retrieval Is Not Top-K</a> → <a href="https://amankumar.ai/blogs/embeddings-part-4">Part 4: From Retrieved Context to a Grounded Answer</a></p><h4>References and further reading</h4><ul><li>Mikolov et al., <a href="https://arxiv.org/abs/1301.3781"><em>Efficient Estimation of Word Representations in Vector Space</em></a></li><li>Google AI Blog, <a href="https://developers.google.com/machine-learning/crash-course/embeddings"><em>Understanding Embeddings</em></a></li><li><a href="https://platform.openai.com/docs/guides/embeddings">OpenAI documentation on embeddings</a></li><li><a href="https://www.sbert.net/docs/">Sentence Transformers documentation</a></li><li>Karpukhin et al., <a href="https://arxiv.org/abs/2004.04906"><em>Dense Passage Retrieval for Open-Domain Question Answering</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e1c548efe06" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[WTF is Tokenization?]]></title>
            <link>https://onlyoneaman.medium.com/wtf-is-tokenization-b079af078bf2?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/b079af078bf2</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Sun, 04 Jan 2026 08:06:17 GMT</pubDate>
            <atom:updated>2026-01-04T08:06:17.194Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*qgdEM9SDu6-VJ8of" /></figure><p>You’ve probably heard that ChatGPT “predicts the next word.” That’s… not quite right. It predicts the next <strong>token</strong>. And if you’ve ever wondered why your AI can’t count letters, struggles with simple math, or occasionally does something completely unhinged, the answer is almost always the same.</p><blockquote><strong>Tokenization.</strong></blockquote><h3>The One Thing You Need to Know</h3><p>LLMs don’t read words. They don’t read characters. They read <strong>token IDs</strong> — integers from a fixed vocabulary.</p><p>Everything else — pricing, context limits, latency, weird behaviors, why Korean costs more than English — flows from this single fact.</p><h3>Why Tokenization Exists</h3><p>Neural networks can’t operate on strings like &quot;insurance&quot; or &quot;नमस्ते&quot;. They need numbers. Tokenization is the bridge:</p><ol><li><strong>Text → tokens</strong> (split into chunks)</li><li><strong>Tokens → token IDs</strong> (lookup in a vocabulary)</li><li><strong>IDs → vectors</strong> (embeddings the model actually processes)</li><li>Model predicts the <strong>next token ID</strong></li><li><strong>Token IDs → tokens → text</strong> (decode back to readable output)</li></ol><p>The “magic” is in the model’s ability to predict what comes next. The <em>interface</em> is tokens.</p><h3>What Exactly Is a Token?</h3><p>A token is <strong>not</strong> a word. A token can be:</p><ul><li>A whole word: &quot;cat&quot;</li><li>Part of a word: &quot;token&quot; + &quot;ization&quot;</li><li>Punctuation: &quot;,&quot;, &quot;.&quot;</li><li>Whitespace (sometimes its own token)</li><li>Single characters (especially for rare strings)</li><li>Or something completely arbitrary like &quot; SolidGoldMagikarp&quot; (more on this nightmare later)</li></ul><p>Most modern LLMs use <strong>subword tokenization</strong> because it hits the sweet spot:</p><ul><li>Word-level vocabularies explode in size (every new word is unknown)</li><li>Character-level sequences get too long (slow and expensive)</li><li>Subwords handle both common words and weird new strings gracefully</li></ul><h3>The Rules of Thumb</h3><p>For English text:</p><ul><li><strong>~1 token ≈ 4 characters</strong></li><li><strong>~100 tokens ≈ 75 words</strong></li></ul><p>But these are <em>averages</em>. Code, URLs, and non-English text break these estimates badly.</p><h3>Why Your Text Becomes Weird Chunks</h3><p>The model’s vocabulary contains pieces like:</p><ul><li>&quot;play&quot;, &quot;ing&quot;, &quot;un&quot;, &quot;believ&quot;, &quot;able&quot;</li><li>&quot;http&quot;, &quot;://&quot;, &quot;.com&quot;</li><li>Common byte-ish fragments for edge cases</li></ul><p>So &quot;tokenization&quot; might become:</p><ul><li>[&quot;token&quot;, &quot;ization&quot;] or</li><li>[&quot;tok&quot;, &quot;en&quot;, &quot;ization&quot;]</li></ul><p>And here’s the kicker: <strong>different models tokenize the same text differently</strong>. Their vocabularies and algorithms vary. That’s why token counts (and costs) differ across models even for identical text.</p><h3>How Tokenizers Are Built: BPE in 60 Seconds</h3><p>Most modern LLMs use <strong>Byte Pair Encoding (BPE)</strong> or a close variant. The algorithm is beautifully simple:</p><ol><li>Start with individual characters (or bytes) as your vocabulary</li><li>Count every adjacent pair in your training data</li><li>Merge the most frequent pair into a new token</li><li>Repeat until you hit your target vocabulary size</li></ol><p>That’s it. The result is a vocabulary that efficiently represents common patterns while still being able to handle anything you throw at it.</p><h3>A Tiny Example</h3><p>Starting text: aaabdaaabac</p><ol><li>Most frequent pair is aa → merge into Z</li><li>Now you have: ZabdZabac</li><li>Most frequent pair is ab → merge into Y</li><li>Now you have: ZYdZYac</li><li>Most frequent pair is ZY → merge into X</li><li>Final: XdXac</li></ol><p>The vocabulary learned: {a, b, c, d, Z, Y, X} where Z=aa, Y=ab, X=ZY</p><p>GPT-2 has a vocabulary of ~50,000 tokens. GPT-4 has ~100,000. These aren’t hand-picked — they’re <em>learned</em> from massive text corpora.</p><h3>The Other Algorithms</h3><ul><li><strong>WordPiece</strong>: Similar to BPE, used in BERT-style models</li><li><strong>Unigram/SentencePiece</strong>: Probabilistic approach, doesn’t require pre-splitting by spaces (great for languages without spaces)</li></ul><p>The differences matter, but the core idea is the same: learn a vocabulary that compresses common patterns efficiently.</p><h3>The Root of All Suffering</h3><p>Andrej Karpathy wasn’t joking when he said tokenization is the “real root of suffering” in LLMs. Here’s the litany:</p><h3>Why can’t LLMs spell words?</h3><p>The model never sees individual letters — it sees tokens. The word &quot;tokenization&quot; is just [&quot;token&quot;, &quot;ization&quot;] to the model. It has to <em>learn</em> that these tokens correspond to specific letter sequences, which it only partially does.</p><h3>Why can’t LLMs reverse strings?</h3><p>Same problem. Reversing &quot;hello&quot; requires knowing the letters, but the model might just see [&quot;hello&quot;] as a single atomic unit.</p><h3>Why are LLMs bad at arithmetic?</h3><p>Numbers are tokenized arbitrarily. &quot;380&quot; might be one token while &quot;381&quot; is two tokens (&quot;38&quot; + &quot;1&quot;). The model has to learn that these wildly different token patterns represent consecutive integers.</p><h3>Why did GPT-2 struggle with Python?</h3><p>Each space of indentation was a separate token. Four spaces = four tokens. Huge waste of context window for something that carries almost no information. GPT-4’s tokenizer groups indentation spaces together.</p><h3>Why are LLMs worse at non-English languages?</h3><p>Tokenizers trained primarily on English are <em>efficient</em> for English. The same meaning in Korean, Japanese, or Hindi often requires 2–4x more tokens. This means:</p><ul><li>More expensive (you pay per token)</li><li>Less fits in context window</li><li>Worse performance overall</li></ul><h3>Why prefer YAML over JSON?</h3><p>JSON’s curly braces, quotes, and colons eat tokens. YAML’s whitespace-based structure is often more token-efficient for the same data.</p><h3>The SolidGoldMagikarp Incident</h3><p>In early 2023, researchers discovered something bizarre. When asked to repeat the string &quot; SolidGoldMagikarp&quot;, ChatGPT would instead say &quot;distribute&quot;. Other weird tokens caused the model to:</p><ul><li>Recite religious texts</li><li>Insult the user</li><li>Claim to be different entities</li><li>Simply refuse to acknowledge the token existed</li></ul><p>What happened? These were <strong>glitch tokens</strong> — strings that got into the tokenizer’s vocabulary during training, but were then <em>absent</em> from the model’s training data.</p><p>The tokenizer learned from a corpus that included Reddit usernames like SolidGoldMagikarp (a prolific poster in r/counting). But when the model itself was trained, that content was filtered out. The result: the model has a token for &quot;SolidGoldMagikarp&quot; but has essentially <em>never seen it used in context</em>.</p><p>The token’s embedding was barely trained. When the model encountered it, the embedding was nearly random — close to the “center” of all token embeddings — causing completely unpredictable behavior.</p><p>This has been patched, but it reveals something important: <strong>tokenization and model training are separate processes</strong>, and misalignment between them can cause weird failures.</p><h3>Why This Actually Matters to You</h3><h3>1. Context Windows Are Measured in Tokens</h3><p>When a model says “128K context window,” that’s 128,000 tokens — not characters, not words. Your budget includes:</p><ul><li>System prompts</li><li>Conversation history</li><li>Tool definitions</li><li>Your content</li><li>The model’s output</li></ul><p>Tokenization is the hidden accountant behind “why did it forget the earlier part?”</p><h3>2. Cost Is Per Token</h3><p>Most APIs bill per input and output token. Even if your text <em>looks</em> short, tokenization can bloat it:</p><ul><li>URLs expand into many tokens</li><li>Code (especially minified) is token-expensive</li><li>Non-English text often costs 2–4x more</li><li>Base64, UUIDs, and hashes are terrible</li></ul><h3>3. Prompt Engineering Interacts with Token Boundaries</h3><p>Tiny formatting changes alter tokenization:</p><ul><li>Extra spaces and newlines</li><li>snake_case_identifiers vs camelCase</li><li>JSON vs plain English</li></ul><p>This can subtly affect both cost and behavior.</p><h3>4. Trailing Whitespace Is Weird</h3><p>&quot;once upon a &quot; (trailing space) tokenizes differently than &quot;once upon a time&quot;. That trailing space becomes its own token, affecting the probability distribution of what comes next.</p><h3>Practical Tips</h3><h4>Use Tokenizer Tools When Precision Matters</h4><p>Rules of thumb are fine for estimates, but for billing and limits, use the actual tokenizer:</p><ul><li><a href="https://aidengpt.com/gpt-tokenizer">GPT Tokenizer</a> — Free online tool with cost estimation</li><li><a href="https://platform.openai.com/tokenizer">OpenAI’s Tokenizer</a></li><li><a href="https://tiktokenizer.vercel.app/">Tiktokenizer</a> for visualization</li><li><a href="https://www.npmjs.com/package/gpt-tokenizer">gpt-tokenizer npm package</a> — TypeScript implementation</li><li>tiktoken library in Python</li></ul><h4>Budget Output Tokens Intentionally</h4><p>Your input tokens + output tokens must fit in the context window. If you’re near the limit, the model might get cut off mid-response.</p><h4>Watch Out for Token-Expensive Content</h4><p>Stuff that bloats token count:</p><ul><li>Minified JSON/JavaScript</li><li>Long URLs with query parameters</li><li>Base64-encoded data</li><li>Log files with UUIDs/hashes</li><li>Non-Latin scripts</li></ul><h4>Summarize Structure, Not Just Content</h4><p>Replacing 50K tokens of raw text with 2K tokens of <em>well-structured</em> summary usually beats brute-forcing more context.</p><h4>Consider YAML Over JSON</h4><p>For structured data in prompts, YAML is often more token-efficient:</p><pre>{&quot;name&quot;: &quot;Alice&quot;, &quot;age&quot;: 30, &quot;city&quot;: &quot;NYC&quot;}</pre><p>vs</p><pre>name: Alice<br>age: 30<br>city: NYC</pre><p>The YAML version typically uses fewer tokens.</p><h3>The Mental Model</h3><p>Here’s how to think about tokenization:</p><blockquote><strong>Tokenization is text compression into a shared dictionary of chunks.</strong></blockquote><p>The better the vocabulary fits your language and domain, the fewer chunks you need, and the more the model can “see” at once.</p><p>A tokenizer trained on English text has learned efficient representations for English patterns. It’s less efficient for Korean. A tokenizer trained on code has learned that (four spaces) is common enough to be a single token.</p><p>The vocabulary is a lossy compression layer between human language and model computation. It’s not perfect, but it’s the best we’ve got.</p><h3>Quick Intuition Check</h3><p>If ~1 token ≈ 4 characters:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ybx0H2k1oJPFKrAgUvhOpQ.png" /></figure><p>But remember: code, URLs, and non-English can blow these estimates way up.</p><h3>The Future of Tokenization</h3><p>Tokenization isn’t going away, but it might get smarter:</p><ul><li><strong>Byte-level models</strong> are being explored — they operate directly on UTF-8 bytes, eliminating the tokenization step entirely. But they’re slower and harder to train.</li><li><strong>Domain-specific tokenizers</strong> can be trained for code, medical text, or other specialized content.</li><li><strong>Multilingual tokenizers</strong> are getting better at efficient representation across languages.</li></ul><p>For now, tokenization remains a quirky but essential piece of the LLM puzzle. Understanding it won’t make you an AI researcher, but it will help you understand why your AI assistant sometimes does inexplicable things.</p><p>The answer is almost always tokenization.</p><h3>TL;DR</h3><ul><li>LLMs don’t read words — they read token IDs (integers)</li><li>Tokens are learned chunks, usually 3–4 characters in English</li><li>BPE (Byte Pair Encoding) learns common patterns from training data</li><li>Context windows, pricing, and behavior all depend on tokens</li><li>Non-English text, code, and URLs are often token-expensive</li><li>Many LLM weirdnesses trace back to tokenization quirks</li><li>Use tokenizer tools when precision matters</li></ul><p><em>Want to see how your text gets tokenized? Try </em><a href="https://aidengpt.com/gpt-tokenizer"><em>GPT Tokenizer</em></a><em> to visualize the chunks.</em></p><h3>References</h3><ul><li><a href="https://platform.openai.com/tokenizer">OpenAI Tokenizer</a> — Official OpenAI tokenizer tool</li><li><a href="https://platform.openai.com/docs/concepts">OpenAI Concepts</a> — OpenAI’s documentation on core concepts including tokens and models</li><li><a href="https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them">What are tokens and how to count them</a> — OpenAI’s guide to understanding tokens and token counting</li><li><a href="https://platform.claude.com/docs/en/build-with-claude/token-counting">Token counting</a> — Anthropic’s documentation on token counting for Claude models</li><li><a href="https://console.anthropic.com/docs/en/api/go/messages/count_tokens">Anthropic API: Count Tokens</a> — Anthropic’s API documentation for token counting endpoint</li><li><a href="https://tiktokenizer.vercel.app/">Tiktokenizer</a> — Interactive token visualization</li><li><a href="https://aidengpt.com/gpt-tokenizer">GPT Tokenizer</a> — Free online tokenizer with cost estimation</li><li><a href="https://www.npmjs.com/package/gpt-tokenizer">gpt-tokenizer npm package</a> — TypeScript implementation for tokenization in your projects</li><li><a href="https://github.com/openai/tiktoken">tiktoken Python library</a> — Fast BPE tokenizer for OpenAI models</li><li><a href="https://medium.com/@onlyoneaman/tokens-embeddings-and-vectors-a-deep-dive-into-nlp-fundamentals-b3c958ccc611">Tokens, Embeddings, and Vectors: A Deep Dive into NLP Fundamentals</a> — Comprehensive guide to tokens, embeddings, and vectors in NLP</li><li><a href="https://youtu.be/7xTGNNLPyMI?si=FRIevrgcmIIphD22&amp;t=6416">Tokenization Deep Dive</a> — Video explanation of tokenization concepts by Andrej Karpathy</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b079af078bf2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A candid review of 2025 into 2026.]]></title>
            <link>https://onlyoneaman.medium.com/a-candid-review-of-2025-into-2026-aa8955edaa93?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa8955edaa93</guid>
            <category><![CDATA[review]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 10:30:05 GMT</pubDate>
            <atom:updated>2026-01-02T10:30:05.410Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*G1NdcHNkKWmguRcc" /></figure><p>2025 was a year of output and motion. I <a href="https://amankumar.ai/projects">shipped</a> a lot, <a href="https://www.instagram.com/_a_gryffindor">traveled</a> a lot, and learned fast. It was also a year where I got clearer about what doesn’t work for me, especially when it comes to focus and the kinds of commitments I allow into my life.</p><h4>What I’m proud of</h4><p><strong>1) I kept shipping, even when the ideas changed.</strong> I launched a bunch of small things and experiments, some quick, some slow and I’m glad I didn’t stop building just because everything wasn’t perfectly aligned. A few examples:</p><ul><li>I shipped a prompts library (<a href="https://promptsmint.com/">Promptsmint</a>) — 100+ Daily Users — and continued improving it as a real asset.</li><li>I launched a couple of micro-builds (small tools, mini-products) that helped me practice distribution + iteration.</li><li>I shipped an iOS app that took longer than expected, but I stuck through the slower “finish it” part.</li></ul><p><strong>2) My AI + product instincts leveled up.</strong> This year I got materially better at building AI/agent-like workflows and turning them into interfaces that feel usable. Less “demo energy,” more “someone could actually use this daily.” That shift matters.</p><p><strong>3) I had a lot of real-world fun</strong> (and it wasn’t a distraction). I did Mumbai/Goa, a long Bali trip, and a month in Thailand/Vietnam, plus a few shorter trips. See more on <a href="https://www.instagram.com/_a_gryffindor">Instagram</a>. Travel didn’t magically solve anything, but it consistently reset my brain and gave me energy. That’s valid.</p><p><strong>4) Reading came back</strong>. I restarted reading and it stuck. It gave me a calmer baseline and better thinking. Quietly one of the highest ROI habits I picked up.</p><h4>What didn’t work (and I’m done pretending it will)</h4><p>1) Fragmentation kills me. I can handle intensity. I don’t handle too many parallel streams well. When <em>projects + plans + people</em> all demand attention at once, my output drops and my mental state follows.</p><p>2) Some relationships/commitments were a net negative. Not naming specifics, but here’s the rule I earned the hard way: If a relationship isn’t net positive — energy, stability, and support — it doesn’t deserve a long trial period. I don’t mean “perfect.” I mean: if it repeatedly costs focus and creates stress without adding something real back, it’s a no. I’ve learned to exit earlier instead of negotiating with my own future.</p><p>3) Activity ≠ progress. I did a lot. But the gap between “busy” and “moving toward the goal” is real. Some of my confusion came from winning small battles while the bigger direction stayed fuzzy.</p><h4>The patterns I noticed (the honest ones)</h4><ul><li>When I start my day reactive, I lose the day.</li><li>When I compound one thing weekly, things move fast.</li><li>When my boundaries are weak, my focus becomes a shared resource and I lose.</li><li>When I build things that are user-facing and practical, I’m in my zone.</li></ul><h4>What I’m taking into 2026</h4><ul><li>I’m keeping the plan simple: Fewer bets, more compounding. One main asset, weekly progress, no constant resets.</li><li>More public artifacts. Small, frequent proof of work beats occasional big announcements.</li><li>Protect focus like it’s a job requirement. Deep work blocks are not optional.</li><li>Health + reading stay steady. They make everything else easier.</li></ul><p>If you want to do your own yearly review, I wrote the exact framework I use here: <a href="https://amankumar.ai/blogs/yearly-review">The Yearly Review (Simple + Actually Useful).</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa8955edaa93" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Agent Skills from Scratch]]></title>
            <link>https://ai.plainenglish.io/building-agent-skills-from-scratch-42dde10c9d28?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/42dde10c9d28</guid>
            <category><![CDATA[skills]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Sat, 27 Dec 2025 07:07:36 GMT</pubDate>
            <atom:updated>2025-12-27T07:07:36.248Z</atom:updated>
            <content:encoded><![CDATA[<h4>How agent skills actually work under the hood — discovery, activation, and execution explained with practical implementation insights.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*62Iw7PmvO5AXut8w" /></figure><p>There’s a lot written about agent skills, but not much about actually implementing them.</p><p>This post shows you how they work and how to integrate them into your existing agent.</p><p><a href="https://github.com/onlyoneaman/agent-skills">View the complete implementation on GitHub</a></p><h3>What Are Agent Skills?</h3><p>Agent skills solve a simple problem: your system prompt gets bloated when you try to make your agent good at everything.</p><p>Instead of this:</p><pre>You&#39;re an expert at code review, git, file organization, API testing... [2000 lines of instructions]</pre><p>You do this:</p><pre>You have access to these skills: <br>- code-review: Reviews code for bugs and security <br>- git-helper: Git workflows and troubleshooting <br>- file-organizer: Organizes files intelligently <br>- api-tester: Tests REST APIs Load them when needed.</pre><h3>The Core Idea</h3><p>Skills are markdown files that live in a directory. Each skill has two parts:</p><ol><li>YAML frontmatter with name and description (see <a href="https://amankumar.ai/blogs/wtf-is-frontmatter">this guide on frontmatter</a> if you’re new to it)</li><li>Markdown body with detailed instructions</li></ol><p>When the agent needs expertise, it loads the relevant skill on the fly.</p><pre>User: &quot;Review this code for SQL injection&quot; <br>  ↓ <br>Agent: &quot;I need the code-review skill&quot; <br>  ↓ <br>System: [Loads SKILL.md with security guidelines] <br>  ↓ <br>Agent: [Follows those guidelines]</pre><p>The key insight is that skills are just structured prompts. But they’re modular, discoverable, and loaded on demand.</p><h3>How It Actually Works</h3><h4>Step 1: Discovery</h4><p>Scan a directory for SKILL.md files and parse their frontmatter. You only load the metadata initially, not the full content. This keeps memory usage low. ( <a href="https://github.com/onlyoneaman/agent-skills">See the discovery implementation</a>)</p><pre>skills/ <br>├── code-review/ <br>│ └── SKILL.md # name: code-review, description: ... <br>├── git-helper/ <br>│ └── SKILL.md</pre><p>During discovery, you extract just the YAML frontmatter (name, description). The full markdown content stays on disk until needed.</p><h4>Step 2: Tool Registration</h4><p>Convert each skill into an <a href="https://platform.openai.com/docs/guides/function-calling">OpenAI function tool</a>. The LLM sees these as callable functions:</p><pre>activate_skill_code_review: &quot;Reviews code for bugs, security, best practices&quot; <br>activate_skill_git_helper: &quot;Git workflows and troubleshooting&quot;</pre><p>The description is critical because it’s what the LLM uses to decide which skill to activate. Be specific and clear.</p><h4>Step 3: Activation</h4><p>When the LLM calls a skill function:</p><ol><li>Load the full SKILL.md content from disk</li><li>Add it to the conversation as a tool result</li><li>Let the LLM continue with those instructions</li></ol><p>This is lazy loading. You only fetch content when actually needed. If you have 20 skills but only use 2, you’ve only loaded 2.</p><h4>Step 4: Execution</h4><p>The LLM reads the skill instructions and follows them. The skill acts like a temporary system prompt for that specific task. Once the task is done, the skill instructions fade from context (unless you keep them for multi-turn conversations).</p><h3>What a Skill Looks Like</h3><pre>--- <br>name: code-review <br>description: Reviews code for bugs, security, and best practices <br>version: 1.0.0 <br>--- <br><br># Code Review Skill <br>You are an expert code reviewer. <br><br>## Check For <br>1. **Security** <br>- SQL injection in queries <br>- XSS in user inputs <br>- Auth bypasses <br>2. **Quality** <br>- Readability <br>- Maintainability <br>- DRY violations <br>3. **Performance** <br>- N+1 queries <br>- Memory leaks <br>- Inefficient algorithms <br><br>## Response Format <br>**Summary**: Brief assessment <br>**Critical Issues**: Security problems (if any) <br>**Improvements**: Suggestions for better code <br>**Positives**: What works well</pre><p>Notice the structure: clear sections, bullet points, and expected output format. The LLM follows structured instructions much better than prose. (For more on crafting effective prompts, see <a href="https://amankumar.ai/blogs/anatomy-of-a-prompt-the-complete-guide-to-crafting-effective-ai-chatgpt-prompts">this guide</a>.)</p><h3>Why This Pattern Works</h3><p><strong>1. Context Efficiency</strong></p><p>Instead of loading 10KB of instructions upfront, you load 100 bytes of metadata. Full instructions only come in when needed. This matters when you’re paying per token.</p><p><strong>2. Modularity</strong></p><p>Each skill is independent. Add a new one by dropping in a SKILL.md file. No code changes needed. Want to remove a skill? Delete the directory.</p><p><strong>3. Clarity</strong></p><p>When debugging, you can see exactly which skill was activated and what instructions it provided. This makes troubleshooting much easier than a monolithic prompt.</p><p><strong>4. Reusability</strong></p><p>Share skills across projects. Someone else’s api-tester skill works in your agent with zero modification. Skills become a shared library of expertise.</p><h3>Key Design Decisions</h3><p>Don’t load all skills into memory at startup. This defeats the purpose because you’re back to loading everything upfront.</p><p>Do load on demand. Parse frontmatter during discovery, but keep full content on disk until the LLM actually requests it.</p><h3>Function Naming</h3><p>Prefix skill functions clearly: activate_skill_code_review. This makes it obvious in logs what&#39;s happening. When you see activate_skill_* in your logs, you know a skill was activated.</p><h3>Conversation Flow</h3><p>The exact sequence matters. Here’s what happens:</p><ol><li>User sends message</li><li>LLM responds with tool_calls (requesting a skill)</li><li><strong>Critical</strong>: Add assistant message with tool_calls to conversation</li><li>Add tool message with skill content</li><li>LLM continues with skill instructions</li><li>Final response</li></ol><p>If you skip step 3, OpenAI will reject your request. The tool_calls must be properly formatted with a type field and nested function object. This is a common gotcha. (See <a href="https://platform.openai.com/docs/guides/function-calling">OpenAI’s tools documentation</a> for details.)</p><h3>Looping for Multiple Tool Calls</h3><p>Skills can chain. A skill might activate code execution, which might need another skill. Your agent should loop until there are no more tool calls:</p><pre>while True: <br>  response = llm.chat(messages=messages, tools=tools) <br>  if not response[&quot;tool_calls&quot;]: <br>    break <br>  handle_tool_calls(response)</pre><p>Always pass tools in every call, even after skill activation. Otherwise, skills can’t use other tools like code execution. ( <a href="https://github.com/onlyoneaman/agent-skills">See full implementation</a> for the complete loop logic.)</p><h3>Practical Considerations</h3><p><strong>Skill Scope</strong></p><p>One skill equals one domain. Keep them focused.</p><p>Good examples: code-review, git-helper, api-tester Bad example: developer-tools (too broad)</p><p><strong>Skill Structure</strong></p><p>Use clear sections with examples:</p><ul><li>What the skill does</li><li>How to approach tasks</li><li>Expected output format</li><li>Examples of good results</li></ul><p>A wall of text doesn’t work. Structure helps the LLM follow instructions.</p><p><strong>Error Handling</strong></p><p>What if a skill doesn’t exist? Return a helpful error:</p><pre>&quot;Skill &#39;xyz&#39; not found. Available: code-review, git-helper&quot;</pre><h3>Common Mistakes &amp; Troubleshooting</h3><p>Some implementations load all skills at startup. This defeats the purpose because you’re back to loading everything upfront, wasting memory and context tokens.</p><p><strong>Fix</strong>: Load metadata only during discovery. Activate skills when needed.</p><h3>Vague Skill Descriptions</h3><p>The LLM uses skill descriptions to decide which to activate. Be specific.</p><p>❌ “Helps with code” ✅ “Reviews Python/JavaScript code for security vulnerabilities, PEP 8 compliance, and performance issues”</p><p>Include what the skill does, what types of tasks it handles, and key capabilities.</p><h3>Wrong Tool Calls Format</h3><p><strong>Error</strong>: Missing required parameter: messages[1].tool_calls[0].type</p><p><strong>Cause</strong>: OpenAI requires a specific nested structure. The tool_calls must have a type field and nest the function details under a function key.</p><p><strong>Fix</strong>: Use the correct format with type: “function” and nested function object. Don’t flatten it. See <a href="https://platform.openai.com/docs/guides/function-calling">OpenAI’s tools documentation</a> for the exact message format.</p><h3>Forgetting to Include Tools After Skill Activation</h3><p><strong>Problem</strong>: After activating a skill, the LLM can’t use other tools like code execution.</p><p><strong>Fix</strong>: Always pass tools in every LLM call. Don’t remove tools after skill activation because skills might need them.</p><h3>No Structure in Skills</h3><p>A wall of text doesn’t work. Use clear headings, bullet points, code examples, and expected output formats. The LLM follows structured instructions much better than prose.</p><h3>When Skills Make Sense</h3><p><strong>Good fit:</strong></p><ul><li>Multi-domain agents that handle code, git, and devops</li><li>Agents with specialized workflows</li><li>Teams sharing common patterns</li><li>When you hit context limits</li></ul><p><strong>Not needed:</strong></p><ul><li>Single-purpose agents</li><li>Agents with small, focused prompts</li><li>Prototypes and experiments</li></ul><p>Don’t over-engineer. If your system prompt is small and manageable, you probably don’t need skills.</p><h3>The Standard</h3><p><a href="https://agentskills.io/">AgentSkills.io</a> defines the open format:</p><ul><li>SKILL.md naming convention</li><li>YAML frontmatter schema</li><li>Directory structure</li><li>Best practices</li></ul><p>Following the standard means your skills work with other implementations. Skills become portable across projects and teams.</p><h3>Building Your First Skill</h3><ol><li>Create the directory: mkdir -p skills/my-first-skill</li><li>Create SKILL.md with YAML frontmatter and markdown instructions</li><li>Integrate SkillsManager into your agent ( <a href="https://github.com/onlyoneaman/agent-skills">see GitHub repo for full code</a>)</li><li>Test it by asking your agent to use the skill and verifying it activates</li></ol><p>That’s it. No code changes needed to add new skills. Just drop in a SKILL.md file.</p><h3>Bottom Line</h3><p>Agent skills are structured prompts with a loading mechanism.</p><p>The pattern works because:</p><ol><li>It keeps context lean by only loading what you need</li><li>It makes agents modular since skills are independent</li><li>It enables skill reuse so you can share skills across projects</li><li>It simplifies debugging with clear activation logs</li></ol><p>You can build a working implementation in an afternoon. The core SkillsManager is about 130 lines of Python. ( <a href="https://github.com/onlyoneaman/agent-skills">View the implementation</a>)</p><p>Start with one skill. See if it helps. Expand from there.</p><p>The complete working implementation is available on <a href="https://github.com/onlyoneaman/agent-skills">GitHub</a>. Use it as a reference or starting point for your own agent.</p><p>Thanks for reading. If you found this useful, you can follow or connect with me here: <a href="https://x.com/onlyoneaman/">x.com</a> <a href="https://www.linkedin.com/in/onlyoneaman/">linkedin</a></p><h3>Resources</h3><ul><li><a href="https://agentskills.io/">AgentSkills.io</a> — Official specification</li><li><a href="https://github.com/anthropics/claude-skills">Claude Skills</a> — Anthropic’s skill examples</li><li><a href="https://github.com/samuelint/open-agent-skills">Open Agent Skills</a> — Community skill library</li><li><a href="https://github.com/onlyoneaman/agent-skills">Working Implementation</a> — Complete code from this tutorial</li><li><a href="https://amankumar.ai/blogs/wtf-is-frontmatter">WTF is Frontmatter?</a> — Understanding frontmatter/metadata in markdown files</li><li><a href="https://amankumar.ai/blogs/anatomy-of-a-prompt-the-complete-guide-to-crafting-effective-ai-chatgpt-prompts">Anatomy of a Prompt</a> — Complete guide to crafting effective AI prompts with structured approaches</li><li><a href="https://platform.openai.com/docs/guides/function-calling">OpenAI Function Calling</a> — Official OpenAI tools documentation</li></ul><p><em>Originally published at </em><a href="https://amankumar.ai/blogs/implementing-agent-skills"><em>https://amankumar.ai</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42dde10c9d28" width="1" height="1" alt=""><hr><p><a href="https://ai.plainenglish.io/building-agent-skills-from-scratch-42dde10c9d28">Building Agent Skills from Scratch</a> was originally published in <a href="https://ai.plainenglish.io/">Artificial Intelligence in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I cut my site’s image payload by 97.7% (83.57 MB → 1.89 MB)]]></title>
            <link>https://javascript.plainenglish.io/i-cut-my-sites-image-payload-by-97-7-83-57-mb-1-89-mb-6e6366be7165?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e6366be7165</guid>
            <category><![CDATA[seo]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[web-design]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Mon, 22 Dec 2025 17:14:23 GMT</pubDate>
            <atom:updated>2025-12-22T17:14:23.699Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*a9R-cspPepIXAYRJ" /></figure><p>I run <a href="https://amankumar.ai/">amankumar.ai</a> on Next.js. Pages would load, layouts would appear, and React would do its thing, but something still felt slow.</p><p>The problem wasn’t that the page didn’t render.</p><p>The problem was this:</p><blockquote>The page renders, but images stay blank for a moment. Then they drop in one by one. And the site doesn’t feel visually complete until later.</blockquote><p>That gap, where placeholders sit there and images arrive late, is subtle, but once you notice it, you can’t unsee it. It makes the site feel heavier than it should.</p><p>So I stopped guessing and looked at the boring part I’d been ignoring: <strong>image payloads</strong>.</p><h3>Why this keeps happening on modern sites (without anyone messing up)</h3><p>This problem shows up a lot more today, even on well-built sites, and it’s not because people are careless.</p><p>A few things are happening at once:</p><ul><li><strong>Design tools export big images by default</strong> Posters, UI mockups, and screenshots often come out as large PNGs.</li><li><strong>AI-generated images are heavy by nature</strong> High detail, high resolution, no concern for delivery size.</li><li><strong>Frameworks don’t change asset intent</strong> Next.js can optimize <em>delivery</em>, but if the source image is huge, it still has to download.</li><li><strong>Image bloat accumulates quietly</strong> No errors, no warnings, just slower visual completion over time.</li></ul><p>The result is exactly what I was seeing: the page loads, but images arrive last.</p><h3>Measuring the problem on amankumar.ai</h3><p>Before touching anything, I measured the image assets in the repo.</p><p>They were a mix of:</p><ul><li>PNGs (most of them)</li><li>some JPG/JPEGs</li><li>different resolutions</li><li>photos, posters, and UI graphics, all mixed together</li></ul><p>After running a single optimization pass, the numbers looked like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-ntDgDiC1roeyl1Vx5bcxg.png" /><figcaption>Optimization Results for amankumar.ai</figcaption></figure><p>This is <strong>repo-level image weight</strong>, not “every page ships 83 MB.” But it clearly showed the root issue. I was carrying a lot of unnecessary image data, and the browser was paying for it.</p><h3>The engineering question I cared about</h3><p>I didn’t want a clever setup. I wanted something:</p><ul><li>repeatable</li><li>boring</li><li>safe for mixed assets</li><li>easy to re-run later</li></ul><p>So the real question became:</p><blockquote>What’s the simplest image pipeline that’s correct most of the time?</blockquote><h3>First principle: pixels matter more than formats</h3><p>Before debating PNG vs WebP vs AVIF, the biggest issue was <strong>pixel count</strong>.</p><p>If an image is 2400px wide but is never rendered above ~800px, shipping the extra pixels is pure waste.</p><p>So I made one hard rule:</p><blockquote><strong>Cap the max dimension at 800px.</strong> If an image is larger, downscale it. If it’s smaller, leave it alone.</blockquote><p>This single decision removes a surprising amount of weight.</p><h3>Image formats: quality vs size (same perceived quality)</h3><p>Once dimensions are sane, format choice actually matters.</p><p>Here’s the practical ranking when comparing images at roughly the same visual quality:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*82DUy84dI-_bNih9whaixw.png" /><figcaption>Comparing Image Formats</figcaption></figure><p>AVIF genuinely compresses better than WebP in many cases.</p><h3>Why I didn’t standardize on AVIF (yet)</h3><p>This is important, because AVIF <em>is</em> genuinely impressive.</p><p>The reason I didn’t standardize on it is <strong>not quality</strong>. It’s <strong>practical browser support and operational safety</strong>.</p><p>According to current browser compatibility data:</p><ul><li>AVIF support is <strong>good</strong>, but not universal</li><li>Some older browsers, embedded webviews, and edge cases still fall back poorly</li></ul><p>You can see the current state clearly here: <a href="https://caniuse.com/?search=avif">https://caniuse.com/?search=avif</a></p><p>For this project, I didn’t want:</p><ul><li>extra format negotiation</li><li>more fallbacks</li><li>“why didn’t this image load on X device?” debugging</li></ul><p>So the decision wasn’t “AVIF is bad.”</p><p>It was:</p><blockquote><strong>WebP is the safest modern default today.</strong> AVIF can be layered later if needed.</blockquote><h3>The tricky part: photos vs UI/posters</h3><p>My repo wasn’t just photos.</p><p>It had:</p><ul><li>UI graphics</li><li>posters with text</li><li>logos and illustrations</li></ul><p>If you treat everything like a photo and apply lossy compression everywhere, UI assets suffer:</p><ul><li>fuzzy text</li><li>halos around edges</li><li>cheap-looking posters</li></ul><p>WebP helped here because it supports <strong>both lossy and lossless modes</strong>.</p><p>The challenge was choosing between them <em>without manual tagging</em>.</p><h3>The simple rule that worked</h3><p>I used one clean signal:</p><ul><li><strong>If the image has transparency (alpha)</strong>, likely UI or graphic, use <strong>lossless WebP</strong></li><li><strong>If it’s fully opaque</strong>, likely a photo, use <strong>lossy WebP</strong> (quality ~80)</li></ul><p>Is this perfect? No. Is it correct often enough to automate safely? Yes.</p><p>That single rule handled mixed assets without human intervention.</p><h3>Metadata: invisible weight</h3><p>Many images carry metadata:</p><ul><li>camera EXIF</li><li>editing history</li><li>embedded profiles</li></ul><p>None of this helps a webpage load faster or look better.</p><p>So I strip metadata unconditionally. Sometimes the savings are small; sometimes they’re large. Either way, it’s free.</p><h3>Sanity check on a very different repo</h3><p>To make sure this wasn’t a one-off, I ran the <strong>same script, unchanged</strong>, on another repo: <a href="https://promptsmint.com/">promptsmint.com</a>, an AI prompts library with only AI-generated images.</p><p><strong>Before optimization</strong></p><ul><li>92 images</li><li><strong>228.12 MB total</strong></li><li><strong>2.48 MB per image (avg)</strong></li></ul><p><strong>After optimization</strong></p><ul><li>92 images</li><li><strong>4.28 MB total</strong></li><li><strong>~50 KB per image (avg)</strong></li></ul><p><strong>Result</strong></p><ul><li><strong>98.0% reduction</strong></li><li><strong>223.84 MB saved</strong></li></ul><p>Different site. Different content. Same outcome.</p><p>That confirmed this wasn’t luck. It was just removing waste.</p><h3>The script</h3><p>I packaged the whole pipeline into a single script and hosted it here:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d1ba2e9ae671e2280a25a600fc44a24d/href">https://medium.com/media/d1ba2e9ae671e2280a25a600fc44a24d/href</a></iframe><p>It:</p><ul><li>finds all <em>jpg/jpeg/png/webp</em></li><li>outputs <em>*-optimized.webp</em> next to originals</li><li>caps size at <strong>800px</strong></li><li>strips metadata</li><li>uses <strong>lossless WebP for transparent images</strong></li><li>uses <strong>lossy WebP for opaque images</strong></li></ul><p>No clever tricks. Just consistent rules.</p><h3>The actual outcome</h3><p>I didn’t magically make Next.js faster.</p><p>What changed is simpler and more important:</p><blockquote>Images arrive earlier. Placeholders disappear sooner. Pages feel visually complete faster.</blockquote><p>That was the slowness I was noticing, and this fixed it.</p><p>Thanks for reading. If you found this useful, you can follow or connect with me here:</p><p><a href="https://x.com/onlyoneaman/">x.com</a> <a href="https://www.linkedin.com/in/onlyoneaman/">linkedin</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e6366be7165" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/i-cut-my-sites-image-payload-by-97-7-83-57-mb-1-89-mb-6e6366be7165">I cut my site’s image payload by 97.7% (83.57 MB → 1.89 MB)</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Export Your Brain: A Simple Way To Make Any AI “Know You” From Day One]]></title>
            <link>https://onlyoneaman.medium.com/export-your-brain-a-simple-way-to-make-any-ai-know-you-from-day-one-a69e8a1c903a?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/a69e8a1c903a</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Wed, 17 Dec 2025 06:16:03 GMT</pubDate>
            <atom:updated>2025-12-17T06:18:02.493Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ylmdp_UQxV1g9MNo" /></figure><p>Every new AI tool treats you like a stranger.</p><p>New chat. New model. New product. Same ritual:</p><ul><li>“I’m a dev, I use React/TS/Tailwind.”</li><li>“Keep it short, show code first.”</li><li>“Don’t give me motivational quotes.”</li></ul><p>You’ve already trained one AI on all of this. It knows your stack, your tone, your quirks, your life context.</p><p>The question is: <strong>how do you steal that “you” and carry it anywhere?</strong></p><p>That’s what this article is about: Not “exporting ChatGPT data”, but <strong>exporting your persona</strong> so any AI, any agent, any system can plug into it.</p><h3>The Real Problem: Your Context Is Trapped</h3><p>We’re in a multi-AI world:</p><ul><li>ChatGPT for ideation / debugging</li><li>Claude / Gemini for writing</li><li>Cursor / Copilot / Replit for coding</li><li>Internal bots at work</li><li>Random tools for notes, docs, email, scheduling</li></ul><p>Each one gets a tiny slice of you. None of them truly “know you”.</p><p>Your preferences, your working style, your constraints, your goals — they’re all split across chats, tabs, and products.</p><p>What we actually want:</p><blockquote>“My AI context should be as portable as my email address.”</blockquote><p>Until the tools natively support that, we hack it: we create a <strong>Persona Memo</strong>.</p><h3>The Idea: A Persona Memo You Can Plug Anywhere</h3><p>Instead of trying to export raw chat history, you ask your main AI:</p><blockquote>“Look at everything you know about me. Compress it into a memo + JSON that any other system can use to work with me.”</blockquote><p>This does three things:</p><ol><li>Gives <em>you</em> a clean “Operating Manual” of yourself.</li><li>Gives <em>other AIs</em> a high-signal context to start from.</li><li>Works <strong>across tools</strong>: ChatGPT, Claude, Grok, Gemini, Cursor, internal agents, whatever.</li></ol><p>You run one good prompt → get back a human-readable memo + machine-readable persona.</p><p>That’s your portable brain.</p><h3>The Master Prompt (Use This On Whatever Knows You Best)</h3><p>Take this and paste it into the AI where you’ve spent the most time (ChatGPT, Claude, etc.):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/69da8c51d014853ad7dc5a66e0c7fe48/href">https://medium.com/media/69da8c51d014853ad7dc5a66e0c7fe48/href</a></iframe><p>What you get back:</p><ol><li><strong>Operating Manual</strong> — human-readable, like a one-pager about “How to work with ”.</li><li><strong>Persona JSON</strong> — machine-readable, ready to be plugged into agents, system prompts, configs, etc.</li></ol><p>This is already a massive upgrade over “Hi, I like React and short answers”.</p><h3>How To Use This Persona In The Wild</h3><p>Once you’ve generated it, you now have a <strong>portable context pack</strong>.</p><p>You can:</p><ol><li><strong>Start any new AI chat like this</strong></li></ol><ul><li>“Here’s my persona. Assume all of this as background whenever you answer.” <em>[paste Operating Manual or a trimmed version]</em></li></ul><p><strong>2. Set it as “custom instructions” / “system prompt”</strong></p><ul><li>Many tools let you define persistent instructions. Drop your memo there and stop repeating yourself.</li></ul><p><strong>3. Wire it into your own agents</strong></p><ul><li>Store the JSON in your DB or config</li><li>Load it into your backend when instantiating an LLM</li><li>Prepend it in the system or developer prompt</li></ul><p>Your internal bots now behave like they’ve worked with you for months.</p><p><strong>4. Use it as onboarding material</strong></p><blockquote>You can even share a cleaned-up version with collaborators: “Here’s how I work, this will save both of us time.”</blockquote><h3>Keep It Tight: Version, Don’t Worship It</h3><p>A few practical notes:</p><ul><li><strong>Update it every 1–3 months</strong> Your stack, goals, priorities shift. Rerun the prompt or manually edit.</li><li><strong>Treat it like config, not scripture</strong> If something feels wrong, change it. This is <em>your</em> OS.</li><li><strong>Be selective with where you paste it</strong> Don’t feed deeply personal / sensitive stuff to random SaaS forms. Keep a “public-safe” persona and a more detailed internal one if needed.</li></ul><h3>Quick “Lite” Prompt (When You Don’t Need JSON)</h3><p>Sometimes you just want a small memo you can paste into a one-off tool.</p><p>Here’s a shorter version:</p><pre>You are an expert integration developer and personal-knowledge summariser.<br><br>Based on everything you know about me in this workspace, create a concise &quot;Operating Manual&quot; for working with me that I can paste into ANY AI tool.<br>Include sections:<br>- Who I am (1–2 lines)<br>- How I work best<br>- How to talk to me<br>- My tech / domain preferences<br>- What to double-check with me<br>- Things to avoid<br>- What I&#39;m currently optimising for<br>Maximum 350 words. Use direct, confident language. Prioritise stable patterns over one-off details.</pre><p>This is your “carry in pocket” version.</p><h3>The Point Of All This</h3><p>You’re already training these models every day just by talking to them.</p><p>Might as well <strong>capture</strong> that and reuse it.</p><ul><li>One good prompt</li><li>One persona memo</li><li>Works across models, products, and your own agents</li></ul><p>So next time you open a new AI tool, you’re not introducing yourself.</p><p>You’re just handing over your Operating Manual and saying:</p><blockquote>“Start here. We’ve got work to do.”</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a69e8a1c903a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TL;DR: Hooked: How to Build Habit-Forming Products]]></title>
            <link>https://onlyoneaman.medium.com/tl-dr-hooked-how-to-build-habit-forming-products-f5d09dbf4ec7?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5d09dbf4ec7</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[product]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[books]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Wed, 17 Dec 2025 06:09:07 GMT</pubDate>
            <atom:updated>2025-12-17T06:09:07.933Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aqs5QUdAbJQkwEMN" /></figure><p>Nir Eyal’s <strong>Hook Model</strong> explains how products like Instagram, WhatsApp, and TikTok turn casual users into daily users.</p><p>It’s a <strong>4-step loop</strong>:</p><h3>1) Trigger → Spark the Action</h3><p>Two types:</p><ul><li><strong>External</strong>: ads, notifications, emails, friend invites.</li><li><strong>Internal</strong>: emotions like <em>boredom, loneliness, procrastination, curiosity.</em></li><li>Great products connect to an <strong>internal trigger</strong>, so users come back <em>without a nudge</em>.</li></ul><h3>2) Action → The Simplest Possible Behavior</h3><p>Users act when they have:</p><ul><li><strong>Motivation</strong></li><li><strong>Ability</strong> (easy enough)</li><li><strong>Trigger</strong></li></ul><p>Examples of tiny actions:</p><ul><li>Scroll</li><li>Tap</li><li>Swipe down to refresh</li><li>Make the action <strong>effortless</strong> = repeated behavior.</li></ul><h3>3) Variable Reward → The Dopamine Hit</h3><p>The reward must be <strong>unpredictable</strong>.</p><p>Three types:</p><ul><li><strong>Tribe</strong> (social rewards: likes, comments, messages)</li><li><strong>Hunt</strong> (information or resources: scrolling feed, TikTok swipe, loot boxes)</li><li><strong>Self</strong> (achievement: leveling up, streaks, progress bars)</li></ul><p>Uncertainty = habit fuel.</p><h3>4) Investment → User Puts Something In</h3><p>When users contribute:</p><ul><li>Time</li><li>Data</li><li>Followers</li><li>Playlists</li><li>Custom settings</li><li>Content</li><li>…they become more likely to return.</li></ul><p>This step also <strong>loads the next trigger</strong>, creating a loop.</p><p>Think:</p><p><em>“I’ve built my playlist here.”</em></p><p><em>“My streak is here.”</em></p><p><em>“My friends are here.”</em></p><h3>Core Idea</h3><p><strong>Habits are formed when you repeatedly solve a user’s internal trigger with a simple action and a variable reward, and then get the user to invest a little.</strong></p><h3>Why It Matters</h3><p>This loop:</p><ul><li>Increases retention</li><li>Reduces marketing cost</li><li>Creates compounding engagement</li><li>Makes switching away painful</li></ul><h3>One-Line Takeaway</h3><p><strong>If your product solves a recurring pain with an easy action and unpredictable reward, and gets users to invest, you’ve built a habit.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5d09dbf4ec7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Got a Professional Email on My Domain Inside Gmail for Free]]></title>
            <link>https://onlyoneaman.medium.com/how-i-got-a-professional-email-on-my-domain-inside-gmail-for-free-b94ead785d1d?source=rss-8a4500a23ecf------2</link>
            <guid isPermaLink="false">https://medium.com/p/b94ead785d1d</guid>
            <category><![CDATA[email]]></category>
            <category><![CDATA[free-domain]]></category>
            <category><![CDATA[domains]]></category>
            <category><![CDATA[gmail]]></category>
            <dc:creator><![CDATA[Aman Kumar]]></dc:creator>
            <pubDate>Mon, 08 Sep 2025 11:05:19 GMT</pubDate>
            <atom:updated>2025-09-08T11:05:19.982Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*A86sMQNzkRANoHek" /></figure><h3>1. The Problem</h3><p>I had a shiny domain — bankstatementconverter.pro — and wanted to use a proper email like hello@bankstatementconverter.pro.<br>The catch?</p><ul><li>I didn’t want to pay for <a href="https://workspace.google.com/">Google Workspace</a> or other hosting.</li><li>I wanted to <strong>send and receive</strong> from inside my existing Gmail, without logging into multiple places.</li><li>And I wanted it <strong>fast</strong> — ideally in 2–3 minutes. (not hours-long setup)</li></ul><p>Most “free” guides either:</p><ul><li>Only let you <strong>receive</strong> mail (no sending), or</li><li>Lock sending behind a paid plan.</li></ul><h3>2. The Winning Combo</h3><p>After a few trials and some reading, the setup that finally worked was:</p><ul><li><a href="https://developers.cloudflare.com/email-routing/"><strong>Cloudflare Email Routing</strong></a> → to receive domain emails into Gmail for free.</li><li><strong>Gmail’s “Send mail as” + </strong><a href="https://support.google.com/accounts/answer/185833?hl=en"><strong>App Password</strong></a> → to send mail as my domain, from inside Gmail.</li></ul><p>It’s 100% free, quick to set up, and good enough for personal or small project use.</p><h3>3. How the Setup Works (in plain English)</h3><p>Think of it like two one-way streets:</p><ul><li><strong>Inbound street (receiving)</strong> → Cloudflare catches any email sent to hello@bankstatementconverter.pro and forwards it to my Gmail inbox.</li><li><strong>Outbound street (sending)</strong> → Gmail sends mail using my Gmail account’s SMTP, but changes the “From” address to show my domain.</li></ul><p>Result:</p><ul><li>People see my domain email in their inbox.</li><li>I see and send everything inside my normal Gmail tab.</li></ul><h3>4. Step-by-Step Implementation</h3><h3>Step 1 — Set up Cloudflare Email Routing</h3><ol><li>Add your domain to <a href="https://dash.cloudflare.com/">Cloudflare</a> (free plan works).</li><li>In the dashboard, go to <strong>Email → Email Routing</strong>.</li><li>Add a forwarding rule:</li></ol><ul><li>Custom address: hello@bankstatementconverter.pro</li><li>Destination address: your Gmail (you@gmail.com).</li></ul><p>4. Cloudflare gives you MX + TXT records — add them in your <a href="https://developers.cloudflare.com/dns/manage-dns-records/">DNS settings</a>.</p><p>5. Test: send an email to hello@… and check if it lands in Gmail.</p><h3>Step 2 — Enable Sending from Gmail</h3><ol><li>In Gmail, go to <strong>Settings → Accounts and Import → Send mail as</strong>.</li><li>Click <strong>Add another email address</strong>.</li><li>Enter:</li></ol><ul><li>Name: Whatever you want to display.</li><li>Email: hello@bankstatementconverter.pro.</li><li>Untick “Treat as alias”.</li></ul><p>4. For SMTP:</p><ul><li>Server: smtp.gmail.com</li><li>Port: 587 (TLS)</li><li>Username: your Gmail address</li><li>Password: <strong>Google App Password</strong> (generate in <a href="https://myaccount.google.com/apppasswords">Google Account → Security → App Passwords</a> — requires 2-Step Verification).</li></ul><p>5. Gmail will send a verification email to hello@… → it’ll arrive in your Gmail → click to confirm.</p><h3>5. Real-World Example</h3><h4>Sent email to Gmail at my domain:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1016/0*FyWhqLuI0mpULlpL.png" /></figure><h4>Replied &amp; Received email forwarded via Cloudflare into Gmail:</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yEm-s8eY5FSpMmiV.png" /></figure><h3>6. Things to Know Before You Call It Done</h3><p><strong>Limitations:</strong></p><ul><li>Cloudflare is receive-only — you still send via Gmail’s servers.</li><li>Email headers will show <strong>“mailed-by: gmail.com”</strong> — fine for most, but not full white-label.</li><li>Not for mass mailing or newsletters — Cloudflare may block abuse (<a href="https://developers.cloudflare.com/email-routing/">source</a>).</li></ul><p><strong>Costs:</strong></p><ul><li>Cloudflare Email Routing: $0</li><li>Gmail SMTP (App Password): $0</li><li>Setup time: <strong>Max 5 minutes</strong></li></ul><h3>7. Optional Upgrades</h3><h4>Option 1 — Full Branding via Zoho Mail</h4><p>If you want emails to show <strong>“mailed-by: yourdomain.com”</strong> in the header and pass strict SPF/DKIM checks:</p><ul><li>Sign up for <a href="https://www.zoho.com/mail/zohomail-pricing.html#forever-free">Zoho Mail’s Forever Free Plan</a> (1 domain, 5 users, 5 GB each).</li><li>Use Zoho’s SMTP in Gmail’s “Send mail as” instead of Gmail SMTP.</li><li>End result: fully white-labeled sending, still $0.</li></ul><h4>Option 2 — Just Use Google Workspace</h4><p>If you prefer a simpler “all-in-one” and are okay with paying:</p><ul><li>Get <a href="https://workspace.google.com/pricing.html">Google Workspace Business Starter</a> (~$6/user/month).</li><li>You get Gmail hosting for your domain, 30 GB storage, and all Google apps in one place.</li><li>This removes all “mailed-by” issues automatically.</li></ul><h3>8. The Takeaway</h3><p>You don’t need to pay for a mailbox if you already love Gmail’s interface.<br>This Cloudflare + Gmail method:</p><ul><li>Gives you a real domain email address,</li><li>Let&#39;s you send/receive in one inbox,</li><li>Costs nothing to run.</li></ul><p>And if you outgrow it, switching the sending part to Zoho SMTP or Google Workspace makes it look fully professional.</p><p>Thanks for reading I hope this guide helped you. Got feedback or an extra tip? Drop a comment or DM; I’d love to hear it.</p><p>Follow me on <a href="https://onlyoneaman.medium.com/">Medium</a> for more hands‑on AI write‑ups.<br>Connect on <a href="https://x.com/onlyoneaman">X</a> or <a href="https://linkedin.com/in/onlyoneaman">LinkedIn</a> so we can swap ideas in real time.</p><h3>References &amp; Helpful Links</h3><ul><li><a href="https://developers.cloudflare.com/email-routing/">Cloudflare Email Routing Docs</a></li><li><a href="https://support.google.com/mail/answer/22370?hl=en">Gmail “Send mail as” Help</a></li><li><a href="https://support.google.com/accounts/answer/185833?hl=en">Google App Passwords Guide</a></li><li><a href="https://www.zoho.com/mail/zohomail-pricing.html#forever-free">Zoho Mail Forever Free</a></li><li><a href="https://workspace.google.com/pricing.html">Google Workspace Pricing</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b94ead785d1d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>