<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>AI Agent on miti99</title><link>https://miti99.com/en/tags/ai-agent/</link><description>Recent content in AI Agent 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/ai-agent/index.xml" rel="self" type="application/rss+xml"/><item><title>Newsletter #101</title><link>https://miti99.com/en/post/2026/05/04/</link><pubDate>Mon, 04 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #101.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ai-assisted-engineering-q1-2026-impact-report"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-assisted-engineering-q1-2026-impact" rel="noopener noreferrer"&gt;AI-Assisted Engineering: Q1 2026 Impact Report&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DX&amp;rsquo;s Q1 2026 report aggregates data from more than 400 companies (expanding the dataset by over 40% compared to the previous quarter) to measure AI&amp;rsquo;s impact on software engineering. AI adoption across surveyed companies has reached 93%. Most notably, Engineering Managers who use AI daily are now shipping &lt;strong&gt;4x&lt;/strong&gt; as much code to production as they did six months ago, doubling the 2x figure recorded last quarter — a sign that the &amp;ldquo;player-coach&amp;rdquo; model, where managers both lead teams and write code directly, is becoming widespread. In terms of time saved, Junior developers using AI daily save &lt;strong&gt;4.9 hours per week&lt;/strong&gt;, overtaking Staff+ engineers (4.8 hours) for the first time, who had previously always led the pack.&lt;/p&gt;
&lt;p&gt;The flip side is equally clear: at some organizations, the change failure rate on deployments can rise by up to 50% (roughly a 2-percentage-point swing), prompting the report to stress that automated testing is &amp;ldquo;no longer optional.&amp;rdquo; &amp;ldquo;Shadow AI&amp;rdquo; — developers bypassing corporate guardrails to use unauthorized AI tools — demands clear usage policies. Companies with fewer than 200 developers are realizing gains faster than large enterprises. Finally, DX notes that these figures are averages across the dataset: AI&amp;rsquo;s impact varies widely across organizations, so every team needs to measure both speed and quality for itself rather than simply benchmarking against industry averages.&lt;/p&gt;
&lt;h2 id="my-ai-workflow-without-losing-my-skills"&gt;&lt;a href="https://marcgg.com/blog/2026/04/15/my-current-ai-workflow/" rel="noopener noreferrer"&gt;My AI Workflow (Without Losing My Skills)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G shares how he leverages AI without losing his programming skills. His concern stems from the &amp;ldquo;automation paradox&amp;rdquo; (he cites an episode of the &lt;em&gt;99% Invisible&lt;/em&gt; podcast on aviation accidents caused by pilots over-relying on autopilot): automation helps us work faster but erodes our skills, making us even more dependent. So he splits his work by category. When planning, he sketches out his own design first before asking Claude, forcing himself to think things through. For personal tools, he &amp;ldquo;vibe codes&amp;rdquo; freely without worrying about quality. For production code, he writes roughly 50% himself, reads every single line generated by AI, and only delegates to Claude Code the parts that are complex yet isolated and well-tested (an &amp;ldquo;Omega Mess,&amp;rdquo; in Sandi Metz&amp;rsquo;s terminology).&lt;/p&gt;
&lt;p&gt;A concrete example is upgrading the voice feature for his boxing training app: he manually fixed older code sections to understand the system, built an MP3 generation tool with ElevenLabs, let Claude finish a large refactoring once the pattern was established, and wrote the UI himself because it was nearly as fast as writing prompts. As a result, a feature that would have taken weeks was completed in days, with the app sitting at 98.84% uptime at the time of writing. The main message: the time saved by AI should be spent thinking more deeply about feature value rather than chasing volume.&lt;/p&gt;
&lt;h2 id="managing-context-in-long-run-agentic-applications"&gt;&lt;a href="https://slack.engineering/managing-context-in-long-run-agentic-applications/" rel="noopener noreferrer"&gt;Managing Context in Long-Run Agentic Applications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack Engineering shares how they manage context for a multi-agent security investigation platform where a single investigation can span hundreds of model calls and generate megabytes of data. The core design principle is &lt;strong&gt;never carrying raw conversation history into subsequent agent calls&lt;/strong&gt;; instead, context is passed exclusively through three continuous summary channels. This approach avoids blowing up the context window, reduces cost and latency, and helps agents respond better to new information because they aren&amp;rsquo;t weighed down by accumulated stale context.&lt;/p&gt;
&lt;p&gt;The first channel is the &lt;strong&gt;Director&amp;rsquo;s Journal&lt;/strong&gt;, a structured working memory that chronologically records decisions, observations, findings, questions, actions, and hypotheses, complete with metadata (phase, round, timestamp) and evidence citations, keeping every agent aligned on the same investigative thread. The second channel is the &lt;strong&gt;Critic&amp;rsquo;s Review&lt;/strong&gt;, which scores the confidence of specialist agents&amp;rsquo; findings across five tiers, from Trustworthy (0.9–1.0) down to Misguided (0.0–0.29). Across 170,000 evaluated findings, 37.7% reached the highest trust tier, while roughly 26% fell into the bottom two tiers (speculative or misguided). The third channel is the &lt;strong&gt;Critic&amp;rsquo;s Timeline&lt;/strong&gt;, which synthesizes the most plausible timeline from the latest review, the previous timeline, and the Director&amp;rsquo;s journal — prioritizing trustworthy evidence, highlighting gaps, and filtering out ungrounded hallucinations.&lt;/p&gt;
&lt;h2 id="how-the-heck-does-shazam-work"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-shazam-work" rel="noopener noreferrer"&gt;How The Heck Does Shazam Work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article visually explains how Shazam identifies a song in just a few seconds, even in a noisy room, based on a counterintuitive idea: &lt;strong&gt;throw away almost all the data&lt;/strong&gt;, keeping only what is truly distinctive. A microphone converts sound into a digital waveform, but raw waveforms are terrible for matching because the same song played louder or softer produces a completely different waveform. Instead, the app applies a &lt;strong&gt;Fast Fourier Transform (FFT)&lt;/strong&gt; to short audio slices to separate out frequencies, then stacks those slices into a spectrogram — a chart of time, frequency, and amplitude. From there, only the loudest peaks are kept, forming a sparse &amp;ldquo;constellation map&amp;rdquo;; background noise rarely produces prominent peaks, making this approach highly noise-resistant.&lt;/p&gt;
&lt;p&gt;To create fingerprints, the system pairs up nearby peaks, with each pair generating a compact hash from three values: the two frequencies and the time delta between them. Lookup uses an &lt;strong&gt;inverted index&lt;/strong&gt; — for each hash, asking which songs contain it — rather than scanning sequentially through millions of tracks, returning results almost instantly. The final step is verification: when enough hashes match with consistent time offsets, the song is identified.&lt;/p&gt;
&lt;h2 id="agents-with-taste"&gt;&lt;a href="https://emilkowal.ski/ui/agents-with-taste" rel="noopener noreferrer"&gt;Agents with Taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski observes that coding agents handle logic very well but struggle with UI design decisions, and proposes a fix: package aesthetic taste into skill files that clearly explain &lt;em&gt;why&lt;/em&gt; a design choice works, then feed them to the agent. His argument is that taste isn&amp;rsquo;t magic — &amp;ldquo;almost every decision about taste has a rational explanation if you look closely enough,&amp;rdquo; and once you can articulate the reason, you can write it down as a rule for an agent to follow consistently.&lt;/p&gt;
&lt;p&gt;The examples are concrete: animations should start from &lt;code&gt;scale(0.95)&lt;/code&gt; rather than &lt;code&gt;scale(0)&lt;/code&gt; because it feels more grounded in the physical world, like a partially deflated balloon; easing functions are chosen via a decision tree, such as &lt;code&gt;ease-out&lt;/code&gt; for elements entering the viewport and &lt;code&gt;ease&lt;/code&gt; for hover state changes. For durations, micro-interactions take 100–150ms, standard UI elements 150–250ms, modals 200–300ms, and UI animations in general should stay under 300ms. For typography, cap line length around 65 characters, use tabular numerals for price columns, and reserve underlines strictly for links. When the logic behind design is documented, developers get much more leverage out of agents without sacrificing quality.&lt;/p&gt;
&lt;h2 id="floating-point-from-scratch-hard-mode"&gt;&lt;a href="https://essenceia.github.io/projects/floating_dragon/" rel="noopener noreferrer"&gt;Floating Point from Scratch: Hard Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julia Desmazes chronicles her journey implementing hardware floating-point arithmetic from scratch — a challenge that had intimidated her for years — for a systolic-array matrix multiplication accelerator. She chose &lt;strong&gt;bfloat16&lt;/strong&gt; (1 sign bit, 8 exponent bits, 7 mantissa bits) because it requires fewer transistors than float16, offers a dynamic range wide enough for error-tolerant AI workloads, and converts easily to float32. To reduce complexity, the design only supports round-toward-zero and omits subnormals, NaNs, and infinities. The adder uses a &lt;strong&gt;dual-path&lt;/strong&gt; architecture: the &amp;ldquo;close path&amp;rdquo; handles subtraction when the exponent difference is less than 2, while the &amp;ldquo;far path&amp;rdquo; handles everything else, avoiding the long critical path of a single-path design; the multiplier uses radix-4 Booth encoding. Both operations complete in a single cycle.&lt;/p&gt;
&lt;p&gt;Verification was done exhaustively across all 2^32 input combinations using Verilator against a C++ reference model via DPI-C; she discovered that the C++ standard library&amp;rsquo;s bfloat16 computes internally in float32 and can differ by up to 1 ULP, requiring carefully defined acceptance criteria. Two designs were taped out on the IHP 130nm process: the full systolic array occupying 126,685 µm², and a standalone pipelined multiplier reaching a design target of &lt;strong&gt;454 MHz&lt;/strong&gt; under nominal conditions. One fun lesson: a leading-zero counter written simply with &lt;code&gt;casez&lt;/code&gt; outperformed a traditional tree-based design, showing just how effectively synthesis tools optimize.&lt;/p&gt;
&lt;h2 id="the-peril-of-laziness-lost"&gt;&lt;a href="https://bcantrill.dtrace.org/2026/04/12/the-peril-of-laziness-lost/" rel="noopener noreferrer"&gt;The Peril of Laziness Lost&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bryan Cantrill argues that LLMs are eroding one of a great programmer&amp;rsquo;s most important virtues: &lt;strong&gt;laziness&lt;/strong&gt;, as defined by Larry Wall — the drive to build powerful abstractions now in order to save effort later. That kind of laziness requires real intellectual effort and time spent pondering a better solution. Human limits on time and stamina used to act as a &lt;em&gt;natural filter&lt;/em&gt; forcing engineers to simplify systems; LLMs have no such limits and can generate endless code without any pressure toward minimalism, leading to bloated systems instead of elegant ones.&lt;/p&gt;
&lt;p&gt;A prime example is Garry Tan bragging about writing 37,000 lines of code a day with an LLM, whereas all of DTrace — a system that transformed the industry — is only around 60,000 lines. Closer inspection of Tan&amp;rsquo;s output revealed redundant test suites, a &amp;ldquo;Hello World&amp;rdquo; Rails app, a stowaway text editor, and eight copies of a logo, one of which was an empty file. Cantrill calls this performative industriousness, inflated by LLMs and &amp;ldquo;grind&amp;rdquo; culture, producing sheer volume without any thought for the maintainers left holding the bag. His conclusion: use LLMs in service of true laziness — paying down technical debt and raising engineering rigor — rather than replacing human design thinking.&lt;/p&gt;
&lt;h2 id="cleaning-up-merged-git-branches-a-one-liner-from-the-cia"&gt;&lt;a href="https://spencer.wtf/2026/02/20/cleaning-up-merged-git-branches-a-one-liner-from-the-cias-leaked-dev-docs.html" rel="noopener noreferrer"&gt;Cleaning Up Merged Git Branches: A One-Liner from the CIA&amp;rsquo;s Leaked Dev Docs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spencer Dixon shares a Git one-liner he found in the Vault7 documents published by WikiLeaks in 2017, which included internal developer onboarding docs for the CIA alongside hacking tools. The command solves a familiar annoyance: after working on a repo for a while, your local machine accumulates dozens of merged branches you no longer use. The original filtered against &lt;code&gt;master&lt;/code&gt;; his updated version for modern repositories compares against &lt;code&gt;origin/main&lt;/code&gt; and excludes both &lt;code&gt;main&lt;/code&gt; and &lt;code&gt;develop&lt;/code&gt;:&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;/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 branch --merged origin/main &lt;span class="p"&gt;|&lt;/span&gt; grep -vE &lt;span class="s2"&gt;&amp;#34;^\s*(\*|main|develop)&amp;#34;&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; xargs -n &lt;span class="m"&gt;1&lt;/span&gt; git branch -d
&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 pipeline chains three steps: &lt;code&gt;git branch --merged origin/main&lt;/code&gt; lists merged branches, &lt;code&gt;grep -vE&lt;/code&gt; strips out the current branch and primary branches to prevent accidental deletion, and &lt;code&gt;xargs&lt;/code&gt; deletes each remaining branch using the lowercase &lt;code&gt;-d&lt;/code&gt; flag, which only deletes branches that have already been merged (into their upstream or HEAD), making it quite safe. The author recommends saving it as a shell alias (he named his &lt;code&gt;ciaclean&lt;/code&gt;) so you don&amp;rsquo;t have to remember the syntax, and running it after deployments to keep your branch list trimmed down to just active work and save a few minutes every week.&lt;/p&gt;
&lt;h2 id="agent-harness-engineering"&gt;&lt;a href="https://addyosmani.com/blog/agent-harness-engineering/" rel="noopener noreferrer"&gt;Agent Harness Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that the quality of a coding agent depends more on its &lt;strong&gt;harness&lt;/strong&gt; — the operational scaffolding around the model — than on the model itself: &amp;ldquo;a mediocre model with a great harness will beat a great model with a bad harness.&amp;rdquo; The gap between what today&amp;rsquo;s models are capable of and what they actually deliver is largely a harness problem. A harness encompasses system prompts and instruction files (&lt;code&gt;AGENTS.md&lt;/code&gt;, skill files), the filesystem and version control for persistent state, sandboxed execution environments, cross-session memory, context management mechanisms like conversation compaction, long-horizon task orchestration through planning and verification loops, and hooks that deterministically enforce rules.&lt;/p&gt;
&lt;p&gt;Key principles include the &amp;ldquo;skill issue&amp;rdquo; mindset: most agent failures stem from poor configuration rather than model capability, which makes the problem tractable. The &lt;strong&gt;Ratchet Principle&lt;/strong&gt; treats every failure as a permanent signal — each mistake gets turned into a configuration rule so the agent never repeats it, and every rule should trace back to a specific incident. Instruction files should stay concise; HumanLayer keeps its &lt;code&gt;AGENTS.md&lt;/code&gt; under 60 lines, like a pilot&amp;rsquo;s pre-flight checklist. Osmani also advises designing backward from desired behavior, ensuring every harness component fills a specific capability gap, and notes that as models get stronger, the harness doesn&amp;rsquo;t disappear — it moves on to tackling harder problems.&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 #96</title><link>https://miti99.com/en/post/2026/04/16/</link><pubDate>Thu, 16 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/16/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #96.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="clean-architecture--separation-of-concerns-trong-go"&gt;&lt;a href="https://vjerci.com/writings/clean/separation-of-concerns/" rel="noopener noreferrer"&gt;Clean Architecture → Separation of Concerns trong Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article explains the principle of Separation of Concerns in Go: once a responsibility is handled in one place in the system, other parts shouldn&amp;rsquo;t have to worry about it or duplicate it. The author opens with an anti-pattern where a single handler function parses an HTTP request, validates the payload, and executes SQL queries directly. When everything is tangled together like that, changing any detail requires understanding the whole stack, and the codebase quickly becomes unmaintainable as complexity grows.&lt;/p&gt;
&lt;p&gt;The fix is splitting the service into four layers: HTTP handlers only decode requests and encode responses, Services hold pure business logic decoupled from infrastructure, Repositories handle all database queries, and Models define data structures with zero dependencies on other layers. Go makes this natural through structural typing: a struct satisfies an interface implicitly without &lt;code&gt;implements&lt;/code&gt; declarations. The author recommends giving each package a single, obvious responsibility and wiring components together via constructor dependency injection so the dependency graph is visible right in &lt;code&gt;main&lt;/code&gt;. Helpful Go tips include using your IDE&amp;rsquo;s &amp;ldquo;Find Implementations&amp;rdquo; shortcut and adding a compile-time interface check like &lt;code&gt;var _ MyInterface = (*MyStruct)(nil)&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-garbage-collector"&gt;&lt;a href="https://internals-for-interns.com/posts/go-garbage-collector" rel="noopener noreferrer"&gt;The Garbage Collector&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This deep dive explores Go 1.26&amp;rsquo;s garbage collector, which introduces the GreenTea GC. Go&amp;rsquo;s collector is a non-moving, concurrent, tri-color mark-and-sweep collector: because objects never move in memory over their lifetime, pointers stay valid and interoperating with &lt;code&gt;unsafe&lt;/code&gt; or C code is much simpler. Each GC cycle runs through four phases: sweep termination, concurrent mark (running alongside application goroutines and capped at roughly 25% of CPU), mark termination, and lazy sweep driven by allocation demand—pausing the program (stop-the-world) only twice for very brief intervals.&lt;/p&gt;
&lt;p&gt;GreenTea&amp;rsquo;s key innovation is queuing entire memory spans (contiguous pages holding same-sized objects) rather than individual object pointers during marking, batching marked objects together before scanning to dramatically improve CPU cache locality. When a span has more than 12.5% of its objects marked, the collector uses AVX-512 SIMD instructions on x86-64 to scan it 4–8x faster. A hybrid Yuasa–Dijkstra write barrier shades both overwritten and newly written pointers during concurrent marking so live objects are never missed. If goroutines allocate faster than background workers can mark, &lt;em&gt;mark assist&lt;/em&gt; forces allocating goroutines to do marking work themselves as backpressure. Finally, the GC Pacer schedules cycles using &lt;code&gt;GOGC&lt;/code&gt; (default 100, triggering when the heap doubles) and &lt;code&gt;GOMEMLIMIT&lt;/code&gt; (a soft memory cap for the Go runtime).&lt;/p&gt;
&lt;h2 id="the-skill-of-using-ai-agents-well"&gt;&lt;a href="https://www.lesswrong.com/posts/9xAwybDhtgzGYPnbs/the-skill-of-using-ai-agents-well" rel="noopener noreferrer"&gt;The Skill of Using AI Agents Well&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post shares practical habits for working effectively with AI coding agents, centered on one insight: the real bottleneck is human attention, not AI capability. Accordingly, the author designs his workflow to minimize personal friction: always use the strongest frontier model at its highest reasoning setting, turn on verbose debug logging so the agent can diagnose failures on its own, and give every AI session its own isolated branch via &lt;code&gt;git worktree&lt;/code&gt; so multiple agents can run in parallel without stepping on each other&amp;rsquo;s files. Tasks that parallelize naturally—like testing five hypotheses at once—get fanned out to subagents.&lt;/p&gt;
&lt;p&gt;For permissions, he recommends whitelisting obviously safe commands, using a secondary AI classifier to auto-approve routine permission prompts, and enabling audio notifications when an agent blocks waiting for human input. Spinning up a fresh agent session purely to review a diff regularly catches bugs the authoring session missed, while a central dashboard across all active sessions makes it easy to see which agents need attention. He also delegates setup chores like spinning up test databases or driving browser UI checks entirely to agents, switches providers promptly whenever a model feels degraded, and is experimenting with cross-session memory systems—though he hasn&amp;rsquo;t found a silver bullet there yet.&lt;/p&gt;
&lt;h2 id="the-unwritten-laws-of-software-engineering"&gt;&lt;a href="https://newsletter.manager.dev/p/the-unwritten-laws-of-software-engineering" rel="noopener noreferrer"&gt;The unwritten laws of software engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This piece rounds up seven unwritten laws that software engineers usually learn only after painful production incidents. First, when production breaks right after a deployment, roll back first and investigate second—don&amp;rsquo;t burn hours trying to prove your commit was innocent while users are down. Second, a backup doesn&amp;rsquo;t exist until you have successfully restored from it; you also need to know your recovery point objective, who has permissions to run the restore, and how long a restore actually takes now that the database is ten times larger. Third, logging is an eternal balancing act: either too sparse to diagnose an outage, or a noisy flood missing a shared correlation/request ID across services.&lt;/p&gt;
&lt;p&gt;Fourth, every data migration needs a tested rollback plan, because an untested rollback plan will almost certainly fail when you need it most. Fifth, every external dependency &lt;em&gt;will&lt;/em&gt; eventually fail—know its rate limits, test how your app behaves when it goes down, and prepare caches, queues, or graceful degradation; chaining two independent 99.9% services in series drops combined availability to ~99.8%. Sixth, risky production operations require the &amp;ldquo;four-eyes principle&amp;rdquo;: have a teammate watch, because simply explaining what you are about to do out loud often catches the mistake. Finally, nothing is more permanent than a temporary hack—so build a small, scoped, clean solution rather than a messy kludge.&lt;/p&gt;
&lt;h2 id="big-tech-engineers-need-big-egos"&gt;&lt;a href="https://www.seangoedecke.com/big-tech-needs-big-egos/" rel="noopener noreferrer"&gt;Big tech engineers need big egos&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke pushes back against the cliché that there is no room for ego in software engineering, arguing that engineers at big tech companies actually need a healthy dose of ego to succeed. Day to day, senior engineers constantly confront their own mistakes and sprawl across codebases too vast for any one person to hold in their head—requiring stubborn self-belief that they can solve problems that look impossible at first glance. Organizationally, strong self-confidence lets an engineer stake out a clear technical position amid ambiguity, make unpopular calls that affect hundreds of peers, and push back when senior leadership misunderstands a technical constraint.&lt;/p&gt;
&lt;p&gt;The paradox is that effective big-tech engineers must also be able to set their ego aside entirely before the org chart: accepting canceled projects, losing internal political battles, or executing murky top-down priorities without becoming bitter. Goedecke calls this the &amp;ldquo;chameleon&amp;rdquo; posture—assertive with peers, yet adaptable toward hierarchy. Burnout, he argues, rarely comes from working too hard; it comes from unrewarded effort, especially when a technically sound decision gets punished because it clashed with organizational politics. Mastering that delicate balance is a big reason truly effective staff-plus engineers are so rare.&lt;/p&gt;
&lt;h2 id="sorting-algorithms"&gt;&lt;a href="https://simonwillison.net/2026/Mar/11/sorting-algorithms/" rel="noopener noreferrer"&gt;Sorting algorithms&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Simon Willison shares how he used Claude Artifacts to build an animated side-by-side visualization of classic sorting algorithms—starting with bubble sort, selection sort, insertion sort, merge sort, quicksort, and heapsort. When asked to add Timsort, Claude autonomously cloned the CPython repository from GitHub and read &lt;code&gt;Objects/listobject.c&lt;/code&gt; and &lt;code&gt;Objects/listsort.txt&lt;/code&gt; to implement it. However, when Willison asked GPT-5.4 Thinking to audit the result, it pointed out that Claude had actually written a simplified adaptive mergesort inspired by Timsort rather than the full algorithm—a great illustration of using one frontier model to cross-check another.&lt;/p&gt;
&lt;p&gt;After a few rounds of UI polish, the artifact gained a &amp;ldquo;Run all&amp;rdquo; button that races all seven algorithms simultaneously in a grid, complete with live comparison and swap counters and color-coded operations: pink for comparisons, orange for swaps, red for pivots, and purple for sorted runs. In the live race, Timsort finishes first, followed closely by quicksort and merge sort, with bubble sort trailing far behind. The post showcases how quickly modern AI tools can turn a conversational prompt into a rich, interactive learning tool.&lt;/p&gt;
&lt;h3 id="bonus"&gt;Bonus&lt;/h3&gt;&lt;p&gt;&lt;strong&gt;Images:&lt;/strong&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F438c4c2f-0fa8-4748-9953-b63fd69674f4_2508x3000.png" alt="12 Claude Code Features Every Engineer Should Know"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F75e97a13-b186-4f16-ab59-f9a96867f744_1899x1536.jpeg" alt="How does REST API work?"&gt;
&lt;img src="https://substackcdn.com/image/fetch/w_1100,c_limit,f_auto,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F0169578f-af50-4b3a-b8ed-542ee7ebf80f_2250x2814.png" alt="7 Key Load Balancer Use Cases"&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></channel></rss>