<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Cursor on miti99</title><link>https://miti99.com/en/tags/cursor/</link><description>Recent content in Cursor on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/cursor/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #44</title><link>https://miti99.com/en/post/2025/08/03/</link><pubDate>Sun, 03 Aug 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/08/03/</guid><description>&lt;p&gt;&lt;em&gt;&lt;del&gt;As mentioned, today I&amp;rsquo;ll try writing the Newsletter with Roo Code. The first few entries will use Roo Code + Qwen 3 Coder.&lt;/del&gt; Enjoy Newsletter #44.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="cursor-unveils-game-changing-web-app-for-ai-coding-agents"&gt;&lt;a href="https://opentools.ai/news/cursor-unveils-game-changing-web-app-for-ai-coding-agents" rel="noopener noreferrer"&gt;Cursor Unveils Game-Changing Web App for AI Coding Agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Anysphere, the company behind the AI code editor Cursor, has launched a web app for managing AI coding agents right from the browser. Instead of opening an IDE, users can assign tasks to agents in natural language, track progress, and merge agent-generated code changes from any internet-connected device. The app complements the existing IDE rather than replacing it, and at launch is available only to Pro tier subscribers and above.&lt;/p&gt;
&lt;p&gt;The article also provides context: Cursor has surpassed $500 million in annual recurring revenue and is used by more than half of the Fortune 500, while Anysphere&amp;rsquo;s CEO predicts that by 2026, AI agents will handle roughly 20% of a software engineer&amp;rsquo;s workload. Although community feedback has been broadly positive, questions remain around handling large repositories, pricing, and privacy. For junior developers, this is a clear signal that delegating to and supervising AI agents is steadily becoming part of everyday work.&lt;/p&gt;
&lt;h2 id="the-heart-of-software-engineering-still-beats"&gt;&lt;a href="https://annievella.com/posts/the-heart-of-software-engineering-still-beats/" rel="noopener noreferrer"&gt;The Heart of Software Engineering Still Beats&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Annie Vella argues that even as AI tools dramatically reshape how we build software, the core of the craft remains intact. In her view, writing code is fundamentally about modeling: forming a structured mental model of a process, system, or idea, and encoding it into something a computer can execute. Design is not a separate phase either, but happens continuously while writing code, testing, debugging, and operating real-world systems; it is this ongoing refinement of abstractions that defines an engineer&amp;rsquo;s craft.&lt;/p&gt;
&lt;p&gt;The article acknowledges that generative AI is triggering an identity crisis: the part of the job many engineers took the most pride in—turning thoughts into code—is now automated, leaving quite a few feeling like bystanders in their own work. Even so, the author sees this as an evolution rather than replacement: modeling skills are shifting to a higher level, from writing code to organizing context for AI tools, also known as context engineering. The joy of shaping invisible systems and watching ideas take form is still there; only the medium of expression has changed.&lt;/p&gt;
&lt;h2 id="expert-generalist"&gt;&lt;a href="https://martinfowler.com/articles/expert-generalist.html" rel="noopener noreferrer"&gt;Expert Generalist&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Martin Fowler, together with Unmesh Joshi and Gitanjali Venkatraman, argues that software organizations overvalue narrow specialization, whereas what truly drives modern software development is the &amp;ldquo;expert generalist&amp;rdquo;: someone with broad knowledge who can still go deep into a few selected areas. The article describes six traits of such people: curiosity to explore new technologies and business domains; willingness to collaborate and humility to learn from specialists when entering unfamiliar territory; customer focus to guide their curiosity; prioritizing foundational knowledge like enduring principles and design patterns over fleeting tools; possessing a blended skill set more complex than a simple T-shaped model; and having &amp;ldquo;empathy&amp;rdquo; for adjacent disciplines, much like a race car driver who understands the car without needing to be a mechanical engineer.&lt;/p&gt;
&lt;p&gt;For organizations, the authors recommend hiring for learning speed and collaboration rather than experience with a specific tool, encouraging staff to rotate across areas, pairing expert generalists with a few deep specialists for each core technology, and building training programs just as rigorous as specialist tracks—such as hands-on workshops building miniature versions of Kafka, Kubernetes, or Delta Lake to grasp their internal design patterns. Generalist capability should also be recognized in promotion criteria.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;The entries above were written using Roo Code with Qwen 3 Coder; overall it was relatively slow and consumed quite a lot of requests. Next, I&amp;rsquo;ll test Roo Code with Kimi K2.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="writing-code-was-never-the-bottleneck"&gt;&lt;a href="https://ordep.dev/posts/writing-code-was-never-the-bottleneck" rel="noopener noreferrer"&gt;Writing code was never the bottleneck&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;The author pushes back against the claim that large language models (LLMs) have solved the core problem of software engineering. Writing code was never the real bottleneck; the most time-consuming activities have always been code review, knowledge transfer, testing, debugging, and team coordination—activities that demand critical thinking and shared understanding across the team.&lt;/p&gt;
&lt;p&gt;LLMs speed up code generation without speeding up verification to match, so they merely shift the bottleneck rather than removing it: code becomes easier to produce but harder to verify, and the team as a whole does not necessarily move faster. Understanding how the code works, finding bugs, and maintaining quality still take substantial effort, and auto-generated code is sometimes even harder to read and review. When code generation outpaces a team&amp;rsquo;s capacity to communicate, reviewers come under heavy pressure and quality easily suffers. The cost of writing code may drop, but the cost of building shared team understanding of the system does not—and that is the true bottleneck.&lt;/p&gt;
&lt;h2 id="building-tiny-ai-tools"&gt;&lt;a href="https://www.seangoedecke.com/building-tiny-ai-tools/" rel="noopener noreferrer"&gt;Building Tiny AI Tools&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke highlights an overlooked area of AI application alongside agentic coding and mass-market AI products: building tiny, personalized tools to automate repetitive workflows. He distinguishes between &amp;ldquo;executive thought&amp;rdquo; (making strategic decisions) and &amp;ldquo;mechanical thought&amp;rdquo; (reading, analyzing, and summarizing information), noting that the latter can now be handed off to AI.&lt;/p&gt;
&lt;p&gt;He gives two examples: &lt;code&gt;gh-standup&lt;/code&gt;, a GitHub CLI extension that pulls commit history and feeds it through an AI prompt to generate a more useful standup report than manual review, and a GitHub Action that aggregates individual engineers&amp;rsquo; updates into a weekly team summary, saving significant time even though it only serves his own company. Tools like these are too niche to sell commercially yet carry high internal value; the clearest sign is that when they break, coworkers immediately speak up. The author believes that as models continue to improve, this kind of automation will become more widespread, and software engineers are best positioned to build them for their own teams.&lt;/p&gt;
&lt;h2 id="modern-git-commands-and-features-you-should-be-using"&gt;&lt;a href="https://martinheinz.dev/blog/109" rel="noopener noreferrer"&gt;Modern Git Commands and Features You Should Be Using&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Most of us use Git every day yet stick to &lt;code&gt;add&lt;/code&gt;, &lt;code&gt;commit&lt;/code&gt;, &lt;code&gt;push&lt;/code&gt;, and &lt;code&gt;pull&lt;/code&gt; as if it were still 2005. Martin Heinz introduces more modern commands: &lt;code&gt;git switch&lt;/code&gt; (Git 2.23) replaces &lt;code&gt;git checkout&lt;/code&gt; for switching branches, adding safety checks to prevent data loss and conveniences like &lt;code&gt;git switch -&lt;/code&gt; to jump back to the previous branch; &lt;code&gt;git restore&lt;/code&gt; consolidates file-restoration tasks previously scattered across &lt;code&gt;reset&lt;/code&gt; and &lt;code&gt;checkout&lt;/code&gt; with clearer syntax; &lt;code&gt;git sparse-checkout&lt;/code&gt; (Git 2.25) populates only the needed directories in the working tree of a large monorepo, and when combined with partial clone also reduces downloaded data; &lt;code&gt;git worktree&lt;/code&gt; lets you check out multiple branches simultaneously in separate directories without stashing or cloning again; and &lt;code&gt;git bisect&lt;/code&gt; uses binary search to pinpoint the commit that introduced a bug.&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch other-branch
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch - &lt;span class="c1"&gt;# Switch back to the previous branch&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git switch remote-branch &lt;span class="c1"&gt;# Switch to a remote branch with automatic tracking&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&lt;/span&gt;&lt;span class="lnt"&gt;7
&lt;/span&gt;&lt;span class="lnt"&gt;8
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Unstage changes&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --staged some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Unstage and discard working tree changes&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --staged --worktree some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Restore a file to a specific commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git restore --source HEAD~2 some-file.py
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git clone --no-checkout https://github.com/example/monorepo
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; monorepo
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git sparse-checkout init --cone
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git checkout main &lt;span class="c1"&gt;# Only checks out files in the root directory&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git sparse-checkout &lt;span class="nb"&gt;set&lt;/span&gt; service/common &lt;span class="c1"&gt;# Only pulls the needed directory&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git worktree add ../hotfix master &lt;span class="c1"&gt;# Create a new worktree from master&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ../hotfix &lt;span class="c1"&gt;# Work independently&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git worktree list &lt;span class="c1"&gt;# List active worktrees&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&lt;/span&gt;&lt;span class="lnt"&gt;4
&lt;/span&gt;&lt;span class="lnt"&gt;5
&lt;/span&gt;&lt;span class="lnt"&gt;6
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect start
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect bad HEAD &lt;span class="c1"&gt;# Current commit is broken&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect good abc123 &lt;span class="c1"&gt;# Last known good commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="c1"&gt;# Git automatically checks out the midpoint commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect good/bad &lt;span class="c1"&gt;# Test and mark the result&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git bisect reset &lt;span class="c1"&gt;# Return to the original commit&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;The takeaway is that when you run into a Git problem, consult the latest official documentation rather than relying on old StackOverflow answers—Git has evolved considerably, and there is likely already a simpler, safer way to solve your problem.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;After testing, I noticed Kimi K2 consistently responds faster than Qwen 3 Coder whether using Cline or Roo Code, and Roo Code makes more requests than Cline, though my satisfaction with the output is roughly the same. Since OpenRouter&amp;rsquo;s rate limit is based on request count rather than total tokens, I&amp;rsquo;ll probably stick with Cline + Kimi K2 as a fallback whenever Claude Code hits its quota.&lt;/em&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #38</title><link>https://miti99.com/en/post/2025/07/28/</link><pubDate>Mon, 28 Jul 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/07/28/</guid><description>&lt;p&gt;&lt;em&gt;Since I still haven&amp;rsquo;t finished my task with &lt;del&gt;Claude Code + Serena MCP&lt;/del&gt; from yesterday&amp;rsquo;s post, today we&amp;rsquo;re back to our boring AI-powered Newsletter series!! Enjoy Newsletter #38 hehe :&amp;gt;&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="9-lessons-from-cursor"&gt;&lt;a href="https://byteatatime.dev/posts/cursor-prompt-analysis/" rel="noopener noreferrer"&gt;9 Lessons From Cursor&amp;rsquo;s System Prompt&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;ByteAtATime pointed Cursor at a custom API endpoint (a local ngrok tunnel) to capture the raw requests the editor sends to the model, dissecting the system prompt for Agent mode running on GPT-4.1 and extracting nine prompt-engineering lessons. First, Cursor defines the persona sharply: the AI is a pair-programming assistant operating inside Cursor as an autonomous agent. Roughly 1,250 tokens of instructions are organized into XML-tagged blocks like &lt;code&gt;&amp;lt;communication&amp;gt;&lt;/code&gt;, &lt;code&gt;&amp;lt;tool_calling&amp;gt;&lt;/code&gt;, and &lt;code&gt;&amp;lt;making_code_changes&amp;gt;&lt;/code&gt; so the model doesn&amp;rsquo;t lose track of directives buried mid-prompt. The prompt repeatedly pushes autonomy: keep going until the user&amp;rsquo;s request is completely resolved, look up information with tools rather than asking the user, and plan before acting. It also tells the model never to mention internal tool names to the user, alongside practical guardrails like not generating long hashes and not attempting to fix linter errors more than three times on the same file.&lt;/p&gt;
&lt;p&gt;Most interestingly, Cursor sends two separate user-role messages: the first carries the user&amp;rsquo;s custom rules, and the second holds the actual query wrapped in rich context including web search results, file contents, and IDE state. As the author sums it up, context is &amp;ldquo;king, queen, and the entire royal court&amp;rdquo;: the more directly relevant information you pack into the prompt, the better the model performs. The final two lessons come from tool design: the file-reading tool returns only 200 to 250 lines per call to protect the context window, while terminal command outputs append stateful metadata like the current working directory so subsequent tool calls stay accurate.&lt;/p&gt;
&lt;h2 id="my-ai-skeptic-friends-are-all-nuts"&gt;&lt;a href="https://fly.io/blog/youre-all-nuts/" rel="noopener noreferrer"&gt;My AI Skeptic Friends Are All Nuts&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas Ptacek (Fly.io) writes a deliberately provocative piece aimed at his AI-skeptic friends: even if LLM progress froze today, it would still be the second most important shift of his career. In his view, most dismissals are anchored in an outdated workflow—asking ChatGPT a question and pasting the snippet into an editor—whereas serious users now work with agents that read project files directly, run Unix tools, interact with Git, run linters, compile, execute tests, and iterate on the output. Because of that feedback loop, he argues, &amp;ldquo;hallucination&amp;rdquo; is largely a solved problem in practice: when an LLM invents a nonexistent function, the agent sees the compiler error and fixes it on the next turn. LLMs can handle the bulk of tedious code, freeing developers to spend their energy on the parts that truly matter.&lt;/p&gt;
&lt;p&gt;Ptacek addresses the remaining objections one by one. You are still responsible for whatever you merge to &lt;code&gt;main&lt;/code&gt;, so review AI-generated code just as you would a colleague&amp;rsquo;s. &amp;ldquo;Mediocre&amp;rdquo; code isn&amp;rsquo;t a dealbreaker because most code doesn&amp;rsquo;t need to be art, and LLMs actually raise the quality floor. LLMs struggling with Rust is mostly a tooling problem today, whereas Go pairs remarkably well with agents. On the craftsmanship argument, he reminds readers that professional developers are paid to solve real problems for people with code, not to act as artisanal woodworkers in their day jobs. He readily concedes that LLMs may shrink software job headcount, and ends by noting that his skeptic friends are sharp engineers—once they actually try coding agents, they&amp;rsquo;ll be even more effective with them than everyone else.&lt;/p&gt;
&lt;h2 id="claude-4-best-practices"&gt;&lt;a href="https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices" rel="noopener noreferrer"&gt;Claude 4 Best Practices&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This is Anthropic&amp;rsquo;s official prompt-engineering guide for Claude models, originally written for Claude 4 and since updated for newer generations. The foundational rule is to write clear, explicit instructions: treat Claude like a brilliant new hire who has zero context on your team&amp;rsquo;s norms. If you want &amp;ldquo;above and beyond&amp;rdquo; output, ask for it explicitly—for example, instead of just saying &amp;ldquo;Create an analytics dashboard,&amp;rdquo; add &amp;ldquo;Include as many relevant features and interactions as possible.&amp;rdquo; Explaining the &lt;em&gt;why&lt;/em&gt; behind a constraint helps Claude generalize toward your real goal; wrap few-shot examples in &lt;code&gt;&amp;lt;example&amp;gt;&lt;/code&gt; tags, and separate instructions, context, and input data with XML tags. For long documents, place the reference material at the top of the prompt and the question at the very end, asking Claude to quote relevant passages before answering.&lt;/p&gt;
&lt;p&gt;To control formatting, tell Claude what to do rather than what &lt;em&gt;not&lt;/em&gt; to do—such as &amp;ldquo;write in smooth, flowing prose paragraphs&amp;rdquo; instead of &amp;ldquo;do not use markdown&amp;rdquo;—and match your prompt&amp;rsquo;s formatting style to the output style you want. The guide also covers leveraging extended thinking to reflect on results after tool calls, encouraging parallel tool execution for independent operations, and tracking state across long-running tasks. For coding specifically, instruct Claude to write general-purpose solutions that work for all valid inputs rather than hardcoding values to pass visible tests, since tests are meant to verify correctness rather than define the implementation.&lt;/p&gt;
&lt;h2 id="stop-over-thinking-ai-subscriptions"&gt;&lt;a href="https://steipete.me/posts/2025/stop-overthinking-ai-subscriptions" rel="noopener noreferrer"&gt;Stop Over-thinking AI Subscriptions&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Peter Steinberger, tired of constantly being asked how much he spends on AI, runs the numbers to show that AI subscriptions are a bargain compared to the time they save. At the time of writing (early June 2025), he calls the $200/month Claude Max 20x plan the best deal in tech: roughly 900 messages per 5-hour window, which translates to virtually unlimited Claude Code usage. Cursor Pro at $20/month includes 500 fast requests and charges $0.04 per extra request, meaning a three-hour live tutorial with over 200 requests cost him only about $8. His biggest variable expense is OpenAI&amp;rsquo;s o3 ($10 per million input tokens, $40 per million output tokens), which makes up roughly half of his total AI bill; developers on a tighter budget can route o3 through a standard ChatGPT subscription using Repo Prompt, or join Anthropic&amp;rsquo;s developer partner program for 30% off API rates. He even built a menu-bar app called Vibe Meter to track spend in real time.&lt;/p&gt;
&lt;p&gt;Addressing fears of future price hikes, Steinberger points out that per-token inference costs have dropped roughly 1,000x over two years and competition continues to drive prices down. For contractors, the math is dead simple: at an $800 day rate, saving a single afternoon a month is worth $200, meaning Claude Max pays for itself in 5 hours and Cursor in 45 minutes. His takeaway: time is the only resource you cannot replenish, and Claude Max was the cheapest way to &amp;ldquo;mint&amp;rdquo; extra working hours.&lt;/p&gt;
&lt;h2 id="tests-should-not-contain-logic"&gt;&lt;del&gt;&lt;a href="https://blog.snork.dev/posts/tests-should-not-contain-logic.html" rel="noopener noreferrer"&gt;Tests Should Not Contain Logic&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;This short post makes a case for keeping logic—especially conditionals and loops—out of unit tests so that when a test fails, you can immediately rule out a bug in the test itself. The author illustrates this with a buggy FizzBuzz implementation: because it checks &lt;code&gt;n % 3&lt;/code&gt; before &lt;code&gt;n % 15&lt;/code&gt;, calling &lt;code&gt;fizzbuzz(15)&lt;/code&gt; returns &lt;code&gt;&amp;quot;fizz&amp;quot;&lt;/code&gt; instead of &lt;code&gt;&amp;quot;fizzbuzz&amp;quot;&lt;/code&gt;. If a developer tries to avoid repetitive assertions by writing a loop that computes the expected value using the exact same &lt;code&gt;if/elif&lt;/code&gt; chain, the test duplicates the production bug and passes anyway. By contrast, &amp;ldquo;obvious&amp;rdquo; flat assertions with literal expected values, like &lt;code&gt;assert fizzbuzz(15) == &amp;quot;fizzbuzz&amp;quot;&lt;/code&gt;, catch the bug immediately.&lt;/p&gt;
&lt;p&gt;To reduce repetition without sneaking logic back into tests, the author recommends parameterized (table-driven) tests: declare a list of explicit &lt;code&gt;(input, expected)&lt;/code&gt; pairs—such as &lt;code&gt;(1, &amp;quot;1&amp;quot;)&lt;/code&gt;, &lt;code&gt;(3, &amp;quot;fizz&amp;quot;)&lt;/code&gt;, &lt;code&gt;(5, &amp;quot;buzz&amp;quot;)&lt;/code&gt;, and &lt;code&gt;(15, &amp;quot;fizzbuzz&amp;quot;)&lt;/code&gt; with &lt;code&gt;@pytest.mark.parametrize&lt;/code&gt; in pytest. That keeps tests concise and readable while verifying each case independently against a concrete literal.&lt;/p&gt;
&lt;h2 id="do-you-really-know-java"&gt;&lt;a href="https://blog.jetbrains.com/idea/2025/05/do-you-really-know-java/" rel="noopener noreferrer"&gt;Do You Really Know Java?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marking Java&amp;rsquo;s 30th anniversary, this JetBrains retrospective looks back at the language&amp;rsquo;s journey. In 1991, James Gosling&amp;rsquo;s team at Sun Microsystems kicked off the Green Project to build software for consumer electronics, needing a lightweight, safe language that could run across any hardware. Originally named Oak after the tree outside Gosling&amp;rsquo;s office window, the language was renamed Java after a trademark clash—likely inspired by Java coffee. Java debuted publicly in 1995 right as the web exploded. Its standout features for the era included &amp;ldquo;write once, run anywhere&amp;rdquo; portability via the JVM, automatic garbage collection, built-in multithreading (now joined by virtual threads from Project Loom), and a sandbox security model that treated untrusted code as a potential threat.&lt;/p&gt;
&lt;p&gt;The post also traces IntelliJ IDEA&amp;rsquo;s arrival in 2001, bringing context-aware code completion, reliable automated refactorings, and real-time static analysis. In the AI era, Java 24 ships over 20 features—including the Vector API to tap specialized CPU instructions for compute-heavy workloads—alongside Projects Panama, Amber, and Valhalla and ecosystem frameworks like LangChain4j and Spring AI. As the article puts it, Java doesn&amp;rsquo;t chase hype; it quietly gets stronger where it counts. Fun closing trivia: Java&amp;rsquo;s mascot Duke was designed by Joe Palrang, who later worked on animated films like &lt;em&gt;Shrek&lt;/em&gt; and &lt;em&gt;Madagascar&lt;/em&gt;.&lt;/p&gt;
&lt;h2 id="machine-code-isn"&gt;&lt;a href="https://jimmyhmiller.com/machine-code-isnt-scary" rel="noopener noreferrer"&gt;Machine Code Isn&amp;rsquo;t Scary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jimmy Miller, who started out writing ActionScript in Flash, shares how he got over his fear of working close to the metal. Once he actually dug in, he realized that if you can make sure a JSON payload conforms to a JSON schema, you can write machine code. Machine code isn&amp;rsquo;t a single universal format—it depends on the processor&amp;rsquo;s instruction set architecture (x86-64 on most PCs, ARM on modern Macs, Raspberry Pis, and phones)—but it revolves around just three concepts: instructions, registers, and memory. On AArch64, every instruction is a 32-bit integer; an add-immediate instruction, for instance, is just a packed bit layout combining a 64-bit flag, a 12-bit immediate value, a source register, and a destination register at fixed bit offsets. Assembly like &lt;code&gt;add x1, x0, #0x2a&lt;/code&gt; is simply a human-readable shorthand for that integer, while &lt;code&gt;str&lt;/code&gt; writes a value to memory much like assigning into a giant array.&lt;/p&gt;
&lt;p&gt;x86-64 is messier because instructions have variable lengths and carry decades of &amp;ldquo;historical baggage,&amp;rdquo; yet the building blocks are the same: a REX prefix for 64-bit operations, a ModR/M byte specifying register or memory addressing, and an opcode. Miller puts those bytes together by hand to encode an instruction that loads the number 42 into the &lt;code&gt;RBX&lt;/code&gt; register. He notes there is still plenty more to learn—status flags, calling conventions, the stack—but getting a minimal program running from raw bytes dissolved the mystique and filled in foundational gaps he had previously papered over with other people&amp;rsquo;s libraries.&lt;/p&gt;
&lt;h2 id="the-art-of-sql-query-optimization"&gt;&lt;a href="https://jnidzwetzki.github.io/2025/06/03/art-of-query-optimization.html" rel="noopener noreferrer"&gt;The Art of SQL Query Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;SQL is declarative: you state &lt;em&gt;what&lt;/em&gt; result you want, and the database engine figures out &lt;em&gt;how&lt;/em&gt; to compute it. The query optimizer enumerates candidate execution plans, estimates their cost, and picks the cheapest one—for example, when a query returns most of a table, a sequential full-table scan is often faster than chasing index pointers. To visualize where PostgreSQL switches plans, Jan Nidzwetzki built Plan Explorer, an open-source tool inspired by the Picasso optimizer visualizer: it runs a parameterized query across a 2D grid of selectivity values and plots the chosen execution plan, estimated cost, actual runtime, estimated row count, and actual row count. It can run entirely in the browser via PGlite (PostgreSQL compiled to WebAssembly) or in server mode against a real PostgreSQL instance using &lt;code&gt;EXPLAIN (ANALYZE)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;On a self-join over an indexed 100,000-row table, Plan Explorer reveals PostgreSQL switching between five distinct execution plans depending on the filter bounds. One neat detail: even when the query is written with a &lt;code&gt;LEFT JOIN&lt;/code&gt;, PostgreSQL executes an &lt;code&gt;INNER JOIN&lt;/code&gt; because a filter on the right-hand table eliminates any &lt;code&gt;NULL&lt;/code&gt;-padded rows the left join would have produced. The visualizations also expose a cardinality-estimation bug: PostgreSQL assumes two filter predicates are correlated when they are actually independent, causing estimated row counts to diverge sharply from reality—a case where extended statistics can help. Beyond the striking visual patterns, Plan Explorer is a practical workbench for anyone tuning or developing custom cost models in PostgreSQL.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #7</title><link>https://miti99.com/en/post/2025/03/16/</link><pubDate>Sun, 16 Mar 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/03/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #7.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-llm-curve-of-impact-on-software-engineers"&gt;&lt;a href="https://serce.me/posts/2025-02-07-the-llm-curve-of-impact-on-software-engineers" rel="noopener noreferrer"&gt;The LLM Curve of Impact on Software Engineers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sergey Tselovalnikov proposes a hypothesis to explain the sharp divide over how useful LLMs really are: their day-to-day value depends heavily on an engineer&amp;rsquo;s seniority, tracing out a distinct curve. For Junior engineers who are still building their mental models of code, LLMs are a lifesaver when deciphering errors, implementing small features, or upgrading libraries. Yet this is also a danger zone: if they just copy and paste code back and forth without understanding why it works, their fundamental skills can stagnate. Mid-level engineers still write code and pick up new frameworks faster with LLMs, but increasingly run into tasks LLMs can&amp;rsquo;t handle—such as figuring out what a customer actually wants from a vague request, hunting down race conditions in a debugger, or handling a 2 a.m. production outage.&lt;/p&gt;
&lt;p&gt;Under this hypothesis, Senior engineers are the most skeptical group. They already hold the system&amp;rsquo;s architecture in their heads, spend a smaller fraction of their day typing boilerplate, and focus on work—roadmapping, debugging gnarly non-reproducible issues, writing design docs—that depends on deep organizational and system context the LLM doesn&amp;rsquo;t have; the more specialized the domain, the sharper the disillusionment. At the Staff+ level, however, the curve bends back up: their job often involves prototyping to blaze trails for other teams, and LLMs drastically speed up building proofs of concept, while their deep expertise lets them immediately spot and untangle whatever corners the model paints itself into. Understanding this curve, the author suggests, builds empathy: the skeptics and the enthusiasts are simply doing very different jobs.&lt;/p&gt;
&lt;h2 id="you-are-using-cursor-ai-incorrectly"&gt;&lt;a href="https://ghuntley.com/stdlib/" rel="noopener noreferrer"&gt;You are using Cursor AI incorrectly&amp;hellip;&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Geoffrey Huntley argues that most engineers—from juniors to principals—are using Cursor the wrong way: treating it as a Google replacement, writing bare-bones prompts like &amp;ldquo;implement XYZ,&amp;rdquo; using it as a text editor rather than an autonomous agent, and failing to realize that you can &amp;ldquo;program&amp;rdquo; the probability distribution of an LLM&amp;rsquo;s output. His solution is to build a personal &amp;ldquo;stdlib&amp;rdquo; (standard library) of thousands of rules stored in &lt;code&gt;.cursor/rules/&lt;/code&gt;, where each rule is a structured &lt;code&gt;.mdc&lt;/code&gt; file defining filters and actions, named with a consistent convention, and composed together like Unix pipes.&lt;/p&gt;
&lt;p&gt;With these rules in place, you can shape Cursor&amp;rsquo;s behavior permanently: when Cursor kept suggesting Bazel commands even though the author wanted Nix exclusively, he wrote a &lt;code&gt;no_bazel&lt;/code&gt; rule to banish Bazel suggestions altogether. Rules also automate development workflows, such as automatically inserting license headers into new files or committing changes once a task is complete. By the author&amp;rsquo;s estimate, current LLMs are only about 45% accurate out of the box and need constant steering, so continuously curating and refining your rule library is the key to getting real leverage out of Cursor.&lt;/p&gt;
&lt;h2 id="how-do-you-spend-your-time"&gt;&lt;a href="https://brooker.co.za/blog/2024/02/06/time.html" rel="noopener noreferrer"&gt;How Do You Spend Your Time?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc Brooker writes for engineers who feel constantly busy and get plenty done, yet worry they aren&amp;rsquo;t spending their time on the highest-value work for their team and projects. His approach is to set an explicit &amp;ldquo;time budget&amp;rdquo;: pick five or six broad categories of work along with a target percentage of time for each, stay flexible week to week while holding the line over the long run, and review the breakdown periodically with your manager. The act of writing the budget down is the most valuable part, because it forces you to think hard about what success actually looks like in your role. His own buckets include individual technical work (writing, reading, and reviewing code, debugging, design docs), mentoring and teaching, long-term strategy, day-to-day operational rhythm, learning (reading papers, prototyping algorithms), and talking with customers. The exact split matters less than doing the exercise deliberately.&lt;/p&gt;
&lt;p&gt;Sticking to a time budget requires learning to say &amp;ldquo;no.&amp;rdquo; Brooker warns against several traps: chasing high-visibility shiny objects or hype, getting sucked into urgent but low-importance chores, and letting your calendar run away from you—like a senior engineer sitting in 20 hours of meetings a week where nobody sees him contributing much, simply because everyone assumes someone else invited him for a good reason. He applies this same lens at the organizational level and borrows the economics concept of &amp;ldquo;revealed preference&amp;rdquo;: how we actually spend our hours reveals our true priorities, just like claiming you love salad while ordering a burger every day.&lt;/p&gt;
&lt;h2 id="we-are-destroying-software"&gt;&lt;a href="https://antirez.com/news/145" rel="noopener noreferrer"&gt;We are destroying software&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In a short, manifesto-style post, Redis creator Salvatore Sanfilippo (antirez) lists the ways we are collectively &amp;ldquo;destroying&amp;rdquo; software: piling on features and premature optimizations without weighing their complexity cost; adopting convoluted build systems; assembling absurd dependency chains that leave everything bloated and fragile; telling junior programmers &amp;ldquo;don&amp;rsquo;t reinvent the wheel&amp;rdquo; when reinventing the wheel is precisely how you learn how wheels work—and the first step toward inventing better ones; abandoning API backward compatibility; pushing rewrites of battle-tested code that already works; and chasing every new language, paradigm, and framework fad.&lt;/p&gt;
&lt;p&gt;He also criticizes the habit of underestimating the cost of wrestling with sprawling third-party libraries compared to writing a focused solution yourself, assuming generic industry standards are always better than custom-fit designs, dismissing code comments as useless, and treating software as a purely mechanical engineering discipline. We build systems that cannot &amp;ldquo;scale down&amp;rdquo;—where simple things ought to remain simple—and optimize for coding velocity over design quality. The end result, he warns, is a field stripped of the joy of hacking.&lt;/p&gt;
&lt;h2 id="nontraditional-red-teams"&gt;&lt;a href="https://zachholman.com/posts/red-teams" rel="noopener noreferrer"&gt;Nontraditional Red Teams&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Former GitHub engineer Zach Holman expands the concept of a &amp;ldquo;red team&amp;rdquo; (adversarial testers who probe a system for weaknesses) beyond cybersecurity to three everyday roles every product team should have. First is the person who checks whether a new graphic or logo accidentally looks like genital or NSFW imagery: GitHub once came dangerously close to printing its very first highway billboard with an illustration that looked uncannily like the infamous &amp;ldquo;goatse&amp;rdquo; shock image, even after dozens of employees had signed off on it. After that near miss, major design launches at GitHub included a dedicated review step asking how a visual might be misread, mocked, or abused out of context. Second is the ad-blocker user, who speaks up whenever a site breaks navigation simply because a tracking script or HTML snippet got blocked—one of the most frustrating experiences on the modern web.&lt;/p&gt;
&lt;p&gt;Third is the password-manager user. Holman vents about how many teams botch even the most basic login forms with custom inputs that prevent 1Password and similar tools from autofilling credentials. None of these are fatal showstoppers since determined users will eventually work around them, he notes, but they are completely avoidable self-inflicted wounds. When a team is heads-down shipping new features, it&amp;rsquo;s easy to miss these rough edges—which is why having an adversarial &amp;ldquo;red team&amp;rdquo; look at the product with fresh, skeptical eyes pays off.&lt;/p&gt;
&lt;h2 id="ai-or-die"&gt;&lt;a href="https://www.rkg.blog/ai-or-die.php" rel="noopener noreferrer"&gt;AI or Die&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Ravi Gupta (RKG) opens with Anthropic CEO Dario Amodei&amp;rsquo;s prediction that as early as 2026 we could see AI models smarter than a Nobel Prize winner across most disciplines, capable of autonomously executing multi-day tasks and running millions of instances in parallel at 10x to 100x human speed—&amp;ldquo;a country of geniuses in a datacenter.&amp;rdquo; Gupta asks: is your company ready to harness that capability, or compete against companies that do? Even today&amp;rsquo;s models can already perform a substantial share of economically valuable work, yet most people barely scratch the surface because they lack ambition, lack the patience to supply rich context, and lack clear thinking and communication.&lt;/p&gt;
&lt;p&gt;To prepare, RKG recommends dedicating a full week to studying what AI can do today and where it is heading; tasking a tiny group to build an &amp;ldquo;AI-native&amp;rdquo; version of your product with a team 10x to 100x smaller; accepting that customers will soon demand dramatically better products at a fraction of the price; going &amp;ldquo;AI-first&amp;rdquo; with the same urgency Facebook once brought to mobile; and auditing every role in the organization to understand who will be supercharged by AI and which functions will be replaced. This isn&amp;rsquo;t an incremental tweak, he argues, but a full-scale &amp;ldquo;refounding&amp;rdquo; of the company—harder the larger and more successful you already are, yet essential to meet a future where, as Sam Altman put it, &amp;ldquo;maybe everyone on earth will be able to accomplish more than the most impactful person can today.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Making the Login Screen Mouse Cursor Look Better</title><link>https://miti99.com/en/post/2020/04/30/</link><pubDate>Thu, 30 Apr 2020 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2020/04/30/</guid><description>&lt;p&gt;As the title suggests, to change the mouse cursor on your login screen, edit the &lt;strong&gt;Inherits&lt;/strong&gt; value in &lt;code&gt;/usr/share/icons/default/index.theme&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Typically, if you want the login screen cursor to match your current desktop cursor, you can check &lt;code&gt;~/.icons/default/index.theme&lt;/code&gt; to see the theme name to use!&lt;/p&gt;
&lt;p&gt;Good luck!&lt;/p&gt;</description></item></channel></rss>