<?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 Hunter Wiginton on Medium]]></title>
        <description><![CDATA[Stories by Hunter Wiginton on Medium]]></description>
        <link>https://medium.com/@hackastak?source=rss-1a52e10d7d73------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*CQD7HPOAr0E0FPj6vqVmYg.jpeg</url>
            <title>Stories by Hunter Wiginton on Medium</title>
            <link>https://medium.com/@hackastak?source=rss-1a52e10d7d73------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 00:00:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hackastak/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[Your Second Brain Is a Landfill: The Memory Rules That Keep Mine Sharp]]></title>
            <link>https://medium.com/@hackastak/your-second-brain-is-a-landfill-the-memory-rules-that-keep-mine-sharp-17f9dda6088b?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/17f9dda6088b</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[pkm]]></category>
            <category><![CDATA[second-brain]]></category>
            <category><![CDATA[obsidian]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 13:16:01 GMT</pubDate>
            <atom:updated>2026-11-11T13:16:01.523Z</atom:updated>
            <content:encoded><![CDATA[<p>My AI second brain is a deliberately small store of memory files. The useful part isn’t the count. It’s that I can still correct any one belief, find it when it matters, and keep stale context from quietly steering a session.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YBY4zoP8qXtchUpHjvdWyw.png" /><figcaption>Image generated by AI</figcaption></figure><p>Most second-brain advice I still see in 2026 focuses on capture. I’ve found the harder problem is deciding what deserves to stay, and how the system should handle it once it does.</p><h3>My first instinct was to keep everything</h3><p>When I started building a second brain, more notes felt like progress. Save the useful detail, keep the interesting thought, make sure nothing slips away. That works for a while. Then you have a growing store of information and no clear way to tell what’s current, duplicated, or worth loading into a task.</p><p>I now keep a small file-based memory that an AI assistant can read and update. The files are plain text. <strong>Obsidian</strong> is the window I use to inspect them, and <strong>Claude Code</strong> is the reasoning engine. Each note records a single durable fact, and a one-line index points to them.</p><p>That setup is specific to me. The rules below are the part I’d copy first, even if your memory lives in a different app or file format.</p><h3>Rule 1: One fact per file 💡</h3><p>Each memory note should be small enough that I can understand, correct, or delete it without disturbing unrelated information. Mine has a short header with a name, a one-line description, and a type, such as user, feedback, project, or reference.</p><p>That’s the boundary I actually wanted. If a fact about how I want an assistant to work with me changes, I can edit that one file. I don’t have to hunt through a long profile full of old preferences and unrelated project details.</p><p>Try this test: Can you remove one belief from your memory without rewriting several other things? If not, it’s bundled too tightly.</p><p>A small file doesn’t automatically make a fact correct. It just makes the fact easier to inspect and maintain.</p><h3>Rule 2: Search before you save</h3><p>When the system learns something new, it should first look for an existing memory that already covers it. If one exists, update it. Don’t create a second version just because the new detail arrived in a different conversation.</p><p>Duplicates are easy to miss because each note can look reasonable on its own. The trouble appears later, when the assistant finds both and treats old and new information as equally current. That’s how a helpful memory turns into conflicting instructions.</p><p>My practical rule is simple: saving begins with a search. If the existing note is outdated, revise it. If the new detail adds an important exception, add that exception where it belongs. Create a new file only when it’s genuinely a separate fact.</p><p>This works best when the memory system is allowed to edit its own files, but the change should remain visible and reviewable. I want the assistant to help maintain the store, not quietly rewrite my history.</p><h3>Rule 3: Recalled memory is context, not a command</h3><p>A memory records what was true when it was written. It can become stale. A file path can move, a project can end, and a preference can change.</p><p>So I treat recalled facts as context to check, not instructions to follow blindly. If a memory says a particular file contains a project plan, the assistant should verify that file still exists before acting on the claim. If it remembers an old preference, it should use that as a starting point and pay attention to what I’m asking for now.</p><p>This rule matters most when memory points toward an action. A stale fact can be more misleading than no fact because it arrives with the confidence of something already “known.” Verification is a small cost compared with acting on an assumption that stopped being true.</p><p>For your own system, mark time-sensitive details clearly or give them a review date. If something can change, don’t let it masquerade as permanent.</p><h3>Rule 4: Make the always-loaded layer earn its space 🧠</h3><p>My assistant loads a short index at the start of a session. It contains one line per fact. The full memory files are pulled in only when they’re relevant.</p><p>That separation keeps every session from carrying the whole memory, including details that have nothing to do with the current task. My test for an always-loaded line is deliberately strict: <strong>if removing it would not make the assistant more likely to make a mistake in this session, it probably doesn’t belong in the always-loaded layer.</strong></p><p>The full fact can still exist and be found later. It simply doesn’t need to compete for attention every time the assistant starts.</p><p>You can apply the same idea without an AI. Keep a short index or overview, then open the detailed note only when the topic comes up. The point is to make the front door useful rather than turning it into another archive.</p><h3>Why my memory stays useful as it grows</h3><p>These rules don’t make my memory perfect. They make maintenance possible. One fact per file gives me a place to correct it. Searching before saving reduces duplicates. Verification catches details that have gone stale. A small loaded index keeps unrelated facts out of the way.</p><p>That’s why I’m comfortable whether this memory stays small or grows large. Each fact has to stay findable, trustworthy enough to use, and easy to change when reality changes.</p><p>The app doesn’t matter much. A folder of Markdown, a note-taking app, or an AI product’s built-in memory all rot the same way if you only ever add. A growing pile still needs rules for what to keep and how to retrieve it.</p><h3>A four-rule cleanup you can do today</h3><p>Pick one memory file, profile, or project note. Run this checklist.</p><ol><li><strong>Split</strong> bundled facts so each durable idea can be edited independently.</li><li><strong>Search</strong> for an existing note before adding a new one.</li><li><strong>Verify</strong> facts that point to changing projects, files, or preferences.</li><li><strong>Trim</strong> the always-visible summary to details that prevent likely mistakes.</li></ol><p>You don’t need to automate the whole process on day one. Start by fixing one duplicate or deleting one stale belief. Then make the next save follow the same rules.</p><p>What’s one fact in your system that you’d hesitate to trust today? Go check it, update it, or delete it. If you’re building an AI-powered vault, two earlier pieces go deeper into the system behind mine. Read “I Built an AI That Argues With My Own Notes” and “10 Commands That Make My Obsidian Vault Think.”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=17f9dda6088b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Wrote 100 Tickets So Seven Engineers Could Start Building: No Manager Title Needed]]></title>
            <link>https://medium.com/@hackastak/i-wrote-100-tickets-so-seven-engineers-could-start-building-no-manager-title-needed-c8dff3341159?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8dff3341159</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 05:42:34 GMT</pubDate>
            <atom:updated>2026-11-04T05:42:34.119Z</atom:updated>
            <content:encoded><![CDATA[<p><em>1,050 hours divided by 7 engineers is 19 days. The number was useless.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yPtlhOpy2EC0Q0gtOZpD2g.png" /><figcaption>Image generated by AI</figcaption></figure><p>1,050 hours of remaining work. Seven engineers. Divide it and you get about 19 business days. Put that number in a status deck and you have just promised a finish date nobody can hit.</p><p>I did that math, then threw it out. The MVP scope was already “agreed,” but the backlog wasn’t real. So I wrote it. First came a rough inventory, then a worse second draft the next day, and finally a little over 100 tickets other people could actually pull. I had no manager title and no authority to commit to a customer date. In this case, engineering leadership was a document.</p><p>If your team is busy and still can’t name the next unblocked ticket, this is the move. You can run a small version of it on one feature family this week.</p><h3>The Scope Was Agreed, but Nobody Could Start.</h3><p>We had the meeting where someone said the scope was nailed down. Friday came. Engineers still didn’t have work they could pick up on Monday.</p><p>A few feature families had real plans. Hours, seams, a sequence. The rest of the program was thirteen features sitting on a single placeholder story each. The tracker said the work existed. The tracker was lying in the polite way trackers lie. It had a title, no decomposition, and no estimate you would bet a week on.</p><p>That is a special kind of stuck. Everyone looks employed. Standup has updates. And the next person who joins the team, or the next team you try to pull in, has nowhere to start except another meeting.</p><p>I had watched that pattern long enough. Invisible status becomes a meeting. A missed date becomes a meeting. An unclear decision becomes a meeting. The cheapest fix I could see was to make the work readable before we talked about it again.</p><h3>You Need a Repo Login, Not a Manager Title</h3><p>I want to be plain about what I didn’t have, because this is the part people use as a reason to wait.</p><p>I couldn’t hire anyone. I couldn’t fire anyone. I couldn’t rate performance. I couldn’t cancel a meeting on the director’s calendar. I also couldn’t walk into a customer conversation and promise a date. If your picture of “stepping up” includes any of that, you are picturing a different job.</p><p>What I had was duller, and it was enough.</p><p>I could read the repo. I could read the board. I could ask the person who owned scope whether a feature was actually in the MVP, and I could ask one engineer who would have to live in the hot file whether my sequence was fantasy.</p><p>If you can open the code and the tracker, you can write the first draft of this plan tonight. Sending it to the PM is part of the method. It keeps you from taking over their job. You are giving them a map of engineering cost and sequence so their priority call is grounded in something real.</p><p>A director sat through the architecture walkthrough later and was surprised I was mid-level. I am not telling you that so you can collect surprise. I am telling you the work was legible without the label. The title didn’t unlock the document. The document made the title look late.</p><h3>Derisk the Plan Before You Create a Ticket</h3><p>The scary version of this story is “I flooded <strong>Jira</strong> with 100 tickets and dared anyone to correct me.” Do not do that version. I almost talked myself out of the whole thing for the usual reasons. I would look like I stole the PM’s job, be wrong in public, duplicate work, and then own the mess forever.</p><p>Every step below exists to make one of those failures cheap. 💡</p><h3>Inventory before you create anything</h3><p>I started with one rollup note, not a ticket create button.</p><p>Four families already had plans that I had done something similar with before and had already gone through refinement. I carried their hours forward, about 630 of them, instead of re-estimating work someone had already decomposed. Thirteen features had no master plan. I marked those hours as guesses on purpose. Plan-grade, not a commitment. Expect the line items to be wrong by about 20 percent. The family totals were firmer than any single row, and even those were going to move.</p><p>If a story already exists, it goes in the “do not recreate” pile. The first job is a census.</p><h3>Check the code, not the status column</h3><p>Then I opened the default branch. This is the step that keeps you from looking careless.</p><p>A story marked done with no artifact in the repo is a question, not a new ticket. A feature with types and a view already merged isn’t greenfield, even if the board still talks about it like a fresh build. A live list page doesn’t need a “flip it to live” story.</p><p>A couple of families looked huge on the board and were mostly shipped. The net-new work was a handful of tickets at about a day each, plus a few places where the tracker said done but the code didn’t contain the thing. Those became open questions for the story owner, not surprise assignments.</p><p><strong>GitHub</strong> is the source of truth for “did we build it.” The tracker is the source of truth for “did we intend to.” You need both, and you need them in that order.</p><h3>Write down the assumption that makes the number true</h3><p>The rough total only held if we built the shared feature seams once, then pointed every other family at them. I wrote that sentence in the doc. If we skipped it, each new family quietly grew by another list page, something like 16 to 24 hours, repeated.</p><p>That sentence is the safety rail on the estimate. A number with no assumption is a promise. A number that says “true only if the shared seam lands first” is a plan someone can challenge. You want the argument now, not a silent re-derivation three weeks later.</p><h3>Show the bottleneck, not the headcount fantasy</h3><p>Here is the table I wish I had put in the first status email.</p><p>Story What it claimed Naive split ~1,050 hours / 7 engineers ≈ 19 business days First pass with dependencies ≈ 44 business days Second pass against the code ≈ 52 business days, and the hours had gone up</p><p>The 19-day number assumes perfect parallelism and zero waiting. We had neither.</p><p>Two of the features work for every family funneled through one controller file. The plans already said not to parallelize same-file work. That lane is one engineer’s serial throughput no matter how many people you add. List and detail screens could not start until the backend read model existed, and until those shared seams existed. The first two weeks would have kept a few people productive while everyone else merged on top of each other.</p><p>Seven engineers didn’t mean a seven-times-faster calendar. Writing that down stops the team from being held to a date the math invented.</p><h3>Name what you would cut before anyone asks you to go faster</h3><p>Two risks sat on top of the schedule, and I wrote the exits in the same doc as the total.</p><p>One family was greenfield from the data contract up. No producer contract in sight. If that contract was not real, that family was the MVP trim, not a heroics project. Another feature had already been flagged as a fast-follow. Cutting it pulled about a week off the file nobody else could touch.</p><p>Bring the option with the bad number. “We are late” is a mood. “Drop this family and this layout feature and the committed path gets shorter by two weeks” is a decision a PM can make on Tuesday.</p><h3>Let the second draft get worse, in public</h3><p>The next day I refined the unplanned families against real breakdowns. The total went up. Working figure around 1,220 hours. Finish line around 52 business days, not 44. Confidence got wider, not tighter, because two families now depended on contracts that did not exist yet.</p><p>The first pass had undercounted. Greenfield backend was heavier than a calibration against families we had already shipped. A dashboard feature I had treated as “shell exists” was actually a rebuild. The hours landed on the same two lanes that were already serialized, so the calendar moved more than “extra hours divided by seven” would predict.</p><p>I kept both numbers. The correction is the credible part. If your first draft is the one you defend, you have started performing certainty, which is the failure mode this whole exercise is supposed to kill.</p><p>Label the doc a draft. Put the date you verified the branch. Invite the PM and the person who owns the hot file to mark it up. Create tickets only after that, and only for rows they agree are net-new.</p><p>That is when the hundred tickets happened. Epics, hour bands, links back to the feature, cross-links to seams that already existed, and hard blockers called out in the open instead of buried inside a 40-hour story. The backlog was the last step. It looks like the bold step because it is the one with a count. The important step was publishing a number that got worse before anyone assigned it.</p><p>The tickets did not magically answer every question. They gave us somewhere to have the right conversation. We could walk through a feature family in a proper refinement, verify what was already there, learn the parts we did not know, and ask and answer the open questions together.</p><p>Before that, discovery meant meetings and back-and-forth across teams that had their own priorities. We had argued that there was not enough time to finish the project, while management reasonably wanted to know how long it would take. Without decomposed work and checked assumptions, we had no estimate we could defend.</p><p>The plan and tickets gave us that plan. It didn’t make a promise that the work would go perfectly, but a schedule with dependencies, risks, and reasons behind it. That let us ask for a delayed delivery date and support from other teams with something stronger than a feeling.</p><h3>Run the Small Version on One Family 🛠️</h3><p>You do not need a 1,000-hour program to use this. If you try to boil the roadmap, you will either stall or make the mess you were afraid of. Pick one family.</p><ol><li>List the tickets that already exist. Mark stub versus real.</li><li>Spend one sitting in the repo. Note what is merged, what is missing, and what the tracker calls done when the code does not contain it.</li><li>Write one page. Hours as a range. The assumption that makes the range true. The single bottleneck. The one thing you would cut.</li><li>Send it to the PM and to one engineer who would do the work. Ask them what you got wrong.</li><li>Create tickets only for the net-new rows they agree on.</li></ol><p>If they ignore the note, you still have a map for your own week. You haven’t flooded the board. That’s the point. A wrong guess in a draft is cheap. A wrong guess in 40 assigned stories is how you become the person nobody wants “helping” with planning again.</p><h3>What Changes for the Team</h3><p>I won’t tell you we shipped early. I don’t have that receipt, and I’m not interested in fabricating one. The impact I can stand behind is narrower, and it was enough to change how the team worked.</p><p><strong>People could start.</strong> A stub story is a title. A story with a seam, an estimate band, and a line that says “blocked on a producer contract” is something another engineer can pull without a meeting to rediscover the shape of the work. Refinement gave us a place to verify the feature family, learn what we did not know, and close open questions. The tickets did not remove discovery; they made discovery specific enough to do together, and gave us somewhere to start building. That is the difference between a backlog and a wishlist.</p><p><strong>The fake calendar died.</strong> The useful number was not 1,050. It was 44, then 52, with the reason written down. Managers could put one owner on the hot file and fan other people across files that would not collide. Nobody was set up to fail a 19-day date the division had invented. We could explain why the estimate had changed, what assumptions it depended on, and what help we needed. That gave management a defensible basis for moving the delivery date and asking other teams to support the work. Most of the stress on a team like this is being accountable for a future nobody can know yet.</p><p><strong>Blockers showed up while they were still cheap.</strong> Missing contracts and a cross-cutting filter feature became schedule risks in a doc, not surprise meetings three weeks later. The plan’s job was to name what was still unknown. Delivery is discovery. An honest backlog shows what is still unknown without making every engineer defend a guess in a room.</p><p><strong>Other people could be added.</strong> Once the program was estimable, another team could be pointed at a family instead of being onboarded by oral history. The written plan became a queue. A director could have an architecture conversation about the system because the sequence was already on paper.</p><p><strong>You don’t have to become the permanent PM.</strong> This is the fear I had, and it is fair. Write the lane table, the trim levers, and the links to the family plans so a teammate can edit the hours without you in the room. Your job ends when the board matches the note. If the doc only works while you narrate it, you built a dependency, not a backlog.</p><p>One engineer stepping up did not multiply the team by writing more code that week. It multiplied the team by making the next seven people able to work without waiting on a meeting to learn what was true.</p><p>Later, I automated the manual work of creating Jira tickets directly from tasks in our sprint plans. That saved about 24 developer hours per sprint on sprint planning and ticket creation alone. The automation was valuable, but it came after the more important hurdle: we first needed the discovery, refinement, and defensible plan that made it clear what tickets to create. Automating the process helped us spend less time translating plans into tracker entries and more time building from work the team understood.</p><h3>The Fears Are Reasonable</h3><p><strong>“This is the PM’s job.”</strong> Prioritization is their job. Engineering cost and sequence are yours to show. You are not taking the priority call. You are making it about a real critical path.</p><p><strong>“I’ll be wrong in public.”</strong> You will. My first total was short. The method assumes a second pass. Ranges, a written assumption, and the word “draft” at the top are the safety gear. Wear them.</p><p><strong>“I’ll create a mess in the tracker.”</strong> Then do not create yet. Census first. Code second. Tickets last, and only for rows someone who owns the family has called net-new.</p><p><strong>“I don’t have the title.”</strong> I did this as a mid-level IC. The document didn’t require a title to be useful, and people noticed the usefulness.</p><p><strong>“They’ll make me maintain it forever.”</strong> Only if you are the only copy. Put the hours where a teammate can change them. Hand the note over with the board update. Stay available for the next correction, not for every status question.</p><h3>Make the Work Legible</h3><p>The leadership move available to you before anyone gives you a title is making the work legible enough for other engineers to execute without you in the meeting.</p><p>Start small. Pick one family, write one page, and ask, “What did I get wrong?” Keep the guesses in the draft until the code and the person who owns scope agree that each row is real.</p><p>Pick the stubbiest family on your board this week. Write the page. Send it to the person who would have to live with the date.</p><p>What did they mark up?</p><h3>The Last Tip</h3><p>If you’re still here, this is the secret sauce: the vast majority of all the work discussed above, can be done by an LLM. You shouldn’t skip refinements because that’s where real engineering gets done, but most of the researching, reading through documents, checking dependency compatibility, finding the owners of internal dependencies, writing story descriptions and acceptance criteria, and splitting a feature request into normal sprint sized tickets can all be done by AI and verified by humans.</p><p>This is exactly how I was able to a lot of this behind the scenes in a few hours that no one even noticed I was working on it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8dff3341159" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Run Your Own AI: How I Put Open-Weight Models on an Old Laptop]]></title>
            <link>https://medium.com/@hackastak/run-your-own-ai-how-i-put-open-weight-models-on-an-old-laptop-d89e8112b7b9?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/d89e8112b7b9</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-10-28T12:11:01.632Z</atom:updated>
            <content:encoded><![CDATA[<p>My spare laptop sits closed on a shelf, and it answers coding questions all day. No API bill, no rate limit, and no model getting swapped out from under me on a random Tuesday.</p><p>That laptop runs an open-weight model I pulled down for free. It isn’t as sharp as the frontier models I pay for, and for a surprising amount of daily work, it doesn’t need to be. The point is that it’s mine, and nobody can change the terms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hIkeJk4DiRh2fOF8D0GDlw.png" /><figcaption>Image generated by AI</figcaption></figure><p>Here’s the thing most of us skipped. In 2026, you probably wired your whole AI workflow into one or two closed providers, and you did it without the scrutiny you give every other dependency. Let me show you the hedge, and how to run it tonight.</p><h3>The dependency you’d never accept anywhere else</h3><p>You vet dependencies for a living. You check a library’s license before you ship it. You worry about a vendor deprecating an API you rely on. You think hard about where your data goes and who gets to read it.</p><p>Then you hand your single newest and most important capability to a company whose model, pricing, and terms can all change next quarter, and you call it a stack.</p><p>I do it too. I use frontier models every day. That’s exactly why the blind spot bugs me. A workflow that only works while two specific vendors keep two specific products cheap and available is a workflow with a single point of failure you didn’t choose on purpose.</p><p>Open-weight models are the hedge. These are models whose weights you can download, run, inspect, and fine-tune on your own hardware. <strong>DeepSeek</strong> and <strong>Qwen</strong> are the two I reach for most, and both are good enough that running them locally stopped being a toy exercise for me months ago.</p><h3>First, the thing everyone assumes</h3><p>Running models yourself does not mean stripping out safety so a model will say something ugly. Skip that framing. It’s the loudest misread of open weights and the least interesting one. It’s also a framing the big providers have little reason to discourage.</p><p>What we’re actually talking about is ownership. Can you run the model offline? Can you point it at private data without shipping that data to someone else’s server? Can you keep today’s behavior frozen even after a provider ships an update you didn’t ask for? With an open-weight model on your own machine, the answer to all three is yes. 💡</p><p>So let’s get one running.</p><h3>Start on easy mode with OpenRouter</h3><p>If you want to feel the difference before you install anything, start with <strong>OpenRouter</strong>. It’s a single API that routes to hundreds of models, open and closed, through one key. You can try DeepSeek or Qwen in about two minutes.</p><p>Sign up, grab an API key, and call it like you’d call any OpenAI-compatible endpoint:</p><pre>curl https://openrouter.ai/api/v1/chat/completions \<br>  -H &quot;Authorization: Bearer $OPENROUTER_API_KEY&quot; \<br>  -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{<br>    &quot;model&quot;: &quot;deepseek/deepseek-chat&quot;,<br>    &quot;messages&quot;: [{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: &quot;Explain a Postgres partial index in two sentences.&quot;}]<br>  }&#39;</pre><p>Swap the model string for qwen/qwen-2.5-72b-instruct and run it again. Same request, different brain, and you can watch the answers diverge.</p><p>This is still someone else’s server, so treat it as a preview before you go local. It’s the fastest way to learn which open-weight model you actually like before you commit disk space to it. Think of it as the test drive.</p><h3>Run it on your own machine with Ollama 🛠️</h3><p>Now the part that changes how you think about all of this. <strong>Ollama</strong> runs open-weight models locally with one command, and it handles the download, the quantization, and the serving for you.</p><p>Install it (brew install ollama on a Mac, or the one-liner on Linux):</p><pre>curl -fsSL https://ollama.com/install.sh | sh</pre><p>Then pull a model and talk to it:</p><pre># a strong 7B that runs on modest hardware<br>ollama run qwen2.5:7b</pre><pre># DeepSeek&#39;s reasoning model, 8B size<br>ollama run deepseek-r1:8b</pre><p>That’s it. The first run downloads the weights, and every run after that is local, offline, and free. No key, no quota, no network.</p><p>The size tag matters more than the name. A 7b or 8b model runs on a normal laptop. The 70b versions want a serious GPU. Start small, because a 7B model that answers instantly beats a 70B model that pins your fan and crawls.</p><p>Want something that isn’t in Ollama’s default library? <strong>Hugging Face</strong> hosts tens of thousands of open models, and Ollama can pull the quantized GGUF builds straight from it:</p><pre>ollama run hf.co/bartowski/Qwen2.5-7B-Instruct-GGUF</pre><p>Hugging Face is where you go to browse, compare, and read how a model was trained. Ollama is how you run what you found. Those two tools cover most of what a solo developer needs to go local.</p><h3>Turn an old laptop into a model server</h3><p>Here’s the move that made this stick for me. I took an old laptop, the kind of machine most people trade in for pocket change, and turned it into a dedicated model server on my home network.</p><p>Ollama serves an HTTP API by default. Tell it to listen on the network instead of just localhost:</p><pre># on the old laptop<br>export OLLAMA_HOST=0.0.0.0:11434<br>ollama serve</pre><p>Then point any other machine in the house at it:</p><pre># on your main machine<br>export OLLAMA_HOST=http://192.168.1.50:11434<br>ollama run qwen2.5:7b</pre><p>Now that shelf laptop is private, always-on, rate-limit-free inference for every device you own.</p><p>For me that machine is a renewed <strong>Surface Laptop 3</strong> (13.5-inch, Intel Core i7–1065G7, 16GB RAM, 256GB SSD) that I wiped and had previously put <strong>Omarchy</strong> on for something different I was doing. There’s no dedicated GPU, just Intel’s integrated graphics, so it runs quantized 7B and 8B models like qwen2.5:7b and deepseek-r1:8b on CPU. They answer at a readable, patient pace rather than instantly, and for everyday questions that&#39;s a trade I&#39;ll happily take. The whole machine cost me less than two months of a frontier plan.</p><p>It’s the cheapest home-lab project on this list, and it’s the one that made “run your own AI” feel less like a slogan and more like a thing humming in the next room.</p><h3>Where it actually paid off</h3><p>Trying models is fun. The payoff showed up when I stopped using an open-weight model as a general chatbot and trained one on a single domain.</p><p>The project that sold me was small and boring in the best way. I trained a <strong>LoRA</strong>, a lightweight adapter that sits on top of a base model without retraining the whole thing, on the official documentation for the stacks I actually work in: Go, TypeScript, React, Next.js, and Python. Just the docs pages, nothing exotic.</p><p>The result is a local model that answers questions about those frameworks grounded in their current docs instead of whatever it half-remembered from its training cutoff. Frontier models are strong here too, and they still confidently invent APIs or reach for an older pattern when a framework moves quickly, and Next.js moves quickly. My doc-tuned model guesses less, points me at the real API more often, and does it offline and for free.</p><p>Here’s why that matters even if you never train anything. A model doesn’t have to be the biggest to be the best at your one job. Feed a mid-size open model the documentation for the tools you use, and it starts to answer like it actually read those docs. You get that without a seven-figure training run and without asking a frontier vendor for permission, a waiver, or a special tier.</p><p>That’s the quiet lesson underneath all the local-AI tinkering. We don’t need a wall of regulation and vendor red tape to do real, useful work with this technology. We need to learn how it works, and we need to stop treating it as something only three companies are allowed to touch.</p><h3>The honest tradeoffs</h3><p>I’m not going to pretend the shelf laptop replaced my frontier subscription. It didn’t.</p><p>What you give up running local:</p><ul><li><strong>Raw capability on hard problems.</strong> For deep multi-step reasoning or large-context work, the frontier models are still ahead. It’s not close on the hardest tasks.</li><li><strong>Speed on weak hardware.</strong> A big model on a CPU-only laptop is patient-making. Match the model size to the machine.</li><li><strong>The managed layer.</strong> You own the updates, the quantization choices, and the babysitting. Nobody tunes it for you.</li></ul><p>What you get back:</p><ul><li><strong>Ownership.</strong> The model runs offline, on hardware you control, with behavior that doesn’t shift unless you shift it.</li><li><strong>Privacy.</strong> Your prompts and your private data never leave the building.</li><li><strong>No meter.</strong> Once it’s downloaded, inference is free and unlimited.</li><li><strong>Independence.</strong> Your workflow stops depending on one vendor’s roadmap matching yours.</li></ul><p>For a lot of daily work, drafting, summarizing, quick code questions, private data, the local model is genuinely enough. For the hard 20%, I still reach for a frontier model, and I do it without feeling like my whole setup would collapse if that option disappeared.</p><h3>What earned a permanent spot 🚀</h3><p>After all the experimenting, here’s what actually stayed in my stack. The old-laptop server earned its spot for private, everyday queries and anything touching data I don’t want on someone else’s servers. OpenRouter earned its spot as the test bench for trying a new open model before I download it. A fine-tuned open model earned its spot for the one narrow domain where it beats a generalist.</p><p>And the frontier models kept their spot too, for the hard problems. They’re one tool among several now, where they used to be the whole foundation. That’s the real win.</p><p>Pull one model tonight. ollama run qwen2.5:7b, ask it the last thing you asked a paid model, and see how close it gets on hardware you already own. Which model are you trying first, and what&#39;s the oldest machine in your closet that could become a model server?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d89e8112b7b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Keep Claude Code in the Smart Zone: Before It Goes Dumb Around 100K Tokens]]></title>
            <link>https://medium.com/@hackastak/keep-claude-code-in-the-smart-zone-before-it-goes-dumb-around-100k-tokens-a2f0b33e325b?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2f0b33e325b</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[context-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 21 Oct 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-10-21T12:11:01.695Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Claude Code</strong> was editing the right files. Then it asked me a question I’d already answered, and the next diff touched a module that had nothing to do with the task.</p><p>If you’ve used it on anything longer than a quick fix, you know the feeling. In 2026 I call the early, reliable part of a session the <strong>Smart Zone</strong>. The model is sharp, it remembers the constraint you set ten minutes ago, and the edits stay inside the files you named.</p><p>The <strong>Dumb Zone</strong> starts when the context gets crowded. Output gets vague. It repeats itself. It “helps” by widening the change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pp4gycX-JMJfj0PFJUc5kw.png" /><figcaption>Image generated by AI</figcaption></figure><p>I treat about 100K tokens as my warning line, not a law of physics. It’s the point in my own Claude Code sessions, and in the workflow notes I keep from Matt Pocock’s AI coding walkthrough, where quality usually starts to slip. A bigger context window gives you more room. It doesn’t cancel the slide. 💡</p><p>Four moves keep me ahead of that slide. I compact on purpose, clear context between phases, plan with a human checkpoint, and run a Ralph Wiggum loop when the work should persist without one giant chat.</p><h3>Context is a working budget</h3><p>Every message, file read, command output, and tool result lands in the same window. Claude has to relate all of it to the next request. That’s the budget. You’re spending it whether you meant to or not.</p><p>The symptoms show up before the session feels broken.</p><ul><li>It re-asks something you already settled.</li><li>It loses the file list or the decision that mattered.</li><li>Edits get broader and less confident.</li><li>Tokens go to re-explaining the task instead of finishing it.</li></ul><p>A larger window just delays that list. It doesn’t remove it.</p><pre>fresh context → productive work → crowded context → quality drop</pre><p>The operating rule is simple. Don’t wait until the output is obviously bad. If you can already feel the session getting noisy, you’re late.</p><h3>Compact before the cliff</h3><p>Compaction means you throw out the running transcript and keep a short state summary. That summary holds the decisions, the file paths, the goal, and what’s still open. Claude Code’s built-in <strong>/compact</strong> does a version of this. I don’t trust it blindly, and I don’t wait for it to fire after the model has already lost the thread. There are also better versions of this out there that you can use a inspiration to build your own, but this is a good starting point.</p><p>A summary written once the session is confused often preserves the confusion. I compact while the session is still coherent. That means around the 100K warning line, after a phase lands, or before I ask for a wide refactor.</p><p>A useful handoff keeps five things and drops the rest.</p><ul><li>The task and what “done” means</li><li>Files already changed, and files still in play</li><li>Decisions, including approaches I rejected</li><li>Test status, failing checks, open questions</li><li>The next action, stated as a verb</li></ul><p>This is the prompt I adapt.</p><pre>Compact this session into a handoff for a fresh Claude Code session.<br>Preserve: goal, constraints, decisions, changed files, test status,<br>open questions, and the next three concrete actions. Remove repetition.</pre><p>Then I start a new session and paste that block. The new session has less history and more signal. That’s the trade I want.</p><p>What I leave out matters as much as what I keep. I drop the dead-end greps, the “let me try that again” turns, and any file Claude opened out of curiosity. If a path isn’t in the handoff, the next session shouldn’t go looking for it unless the spec says so.</p><p>Filled in, a handoff looks boring on purpose. This is the shape, using a checkout change as the example.</p><pre>Goal: add idempotency keys to the checkout POST. Done means a replay with the same key returns the original response and does not create a second charge.<br>Decisions: store the key on the payment row, not a new table. Rejected a Redis lock because we already have the row.<br>Files: payments/checkout.ts, payments/checkout.test.ts. Do not touch the webhook handler.<br>Verification: unit tests green. Integration test not run yet.<br>Next: write the replay test, then the handler change. Stop after the test fails for the right reason.</pre><p>That’s enough for a fresh session to start in the Smart Zone. A 40-message transcript of how I got there is not.</p><h3>Clear the context between phases</h3><p>One long session wants to own the whole feature. That’s how you fill the budget with exploration, a plan, an implementation, a review, and three course corrections, all stacked on top of each other.</p><p>I split the work and clear between phases. The human checkpoint is the point. I read the plan or the diff before the next phase starts, so one session can’t silently accumulate every assumption.</p><p>A feature usually looks like this.</p><ol><li>Inspect the repo and name the affected files. No edits yet.</li><li>Write the plan and stop.</li><li>Implement one bounded slice, often the data shape and its tests.</li><li>Implement the interface against that slice.</li><li>Run the checks, clean up, and stop again.</li></ol><p>Each phase gets a fresh context and a handoff I can skim in under a minute.</p><pre>## Goal<br>## Completed<br>## Decisions<br>## Files that matter<br>## Verification<br>## Next phase</pre><p>If I can’t fill that template in a few precise bullets, the session is already too noisy to continue. I compact or restart before I ask for the next slice.</p><p>Phase-clearing feels slower the first time you do it. The time comes back when you stop paying the tax of “wait, why did it touch that file?” and stop re-litigating decisions the model half-remembers.</p><h3>Use a Ralph Wiggum loop when the job should persist</h3><p>Some work shouldn’t live in one chat at all. The Ralph Wiggum loop, named for the <em>Simpsons</em> kid who keeps trying, is a while-loop with a spec. You write a short PRD or feature spec. Then you feed the agent that spec plus the current state, let it take one small step, check the result, and record progress. Repeat until the spec is done or a stop condition hits.</p><pre>while the task is incomplete:<br>    give Claude the current spec and state<br>    let it complete one small step<br>    run checks<br>    record progress<br>    stop if checks fail, the spec is ambiguous, or the next step is risky</pre><p>The source of truth is the spec and the progress note, not an ever-longer conversation. Each turn can start clean. The loop creates the restart points for you.</p><p>Two constraints keep this from becoming “let it run all night.” The step has to be bounded, and the completion check has to be explicit. Tests pass, the endpoint returns the shape in the spec, the migration applies cleanly. If you can’t name the check, you don’t have a loop. You have a hope.</p><p>Persistence is for iteration. It is not permission for the agent to approve its own risky changes, force-push, or keep going after a check fails. I stop the loop for a failed test, an ambiguous requirement, or anything destructive. Then I read the state and decide whether the next prompt is a fix or a question for me.</p><p>This pairs with the earlier moves. Compaction is the handoff. Phase-clearing is the checkpoint. The loop is how I keep those checkpoints coming when the feature is bigger than one sitting.</p><h3>The procedure I actually run</h3><p>I don’t pick one technique and ignore the others. This is the loop I run on real work. 🛠️</p><ol><li>Start with a narrow goal and a written success condition.</li><li>Ask Claude to inspect before it edits.</li><li>Work one phase, on a limited file set.</li><li>Verify with tests, lint, or a diff review. I read the diff.</li><li>Record the result and the next step in the handoff template.</li><li>Compact or restart before the session gets noisy.</li><li>Repeat until the feature matches the spec.</li></ol><p>I restart when any of these are true.</p><ul><li>It’s repeating itself.</li><li>It forgot a decision from earlier in the same session.</li><li>The task changed shape.</li><li>The next phase touches different files or a different success check.</li><li>I can no longer summarize the session in a few precise bullets.</li></ul><p>That last one is the honest test. If you can’t brief a fresh session, the current one is already in the Dumb Zone. Starting over with a tight brief beats bargaining with a crowded one.</p><h3>Keep the agent in the zone</h3><p>The session that went sideways didn’t need a cleverer prompt. It needed a boundary. I compacted what was still true, started clean, and gave the next session one job. Finish the slice, run the checks, and stop.</p><p>Context is a budget. Spend it on the files and decisions that matter, and close the tab before the model starts spending it on its own confusion.</p><p>Which symptom hits you first? The repeated question, the forgotten decision, or the diff that wandered? And are you compacting, starting fresh between phases, or running a spec in a loop?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2f0b33e325b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vim in 2026: Why I Still Use Neovim and When I Don’t]]></title>
            <link>https://medium.com/@hackastak/vim-in-2026-why-i-still-use-neovim-and-when-i-dont-d94f92d9edde?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/d94f92d9edde</guid>
            <category><![CDATA[vim]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[editor]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-10-07T12:11:01.585Z</atom:updated>
            <content:encoded><![CDATA[<p>I use <strong>Claude Code</strong> and <strong>Cursor</strong> every day, and I still edit in <strong>Neovim</strong>. That combination confuses people, so here’s the honest accounting of why Vim earned its spot in an AI-first workflow in 2026, where it falls short, and whether the weeks of learning curve are worth it for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y_xEQVf8QuX5PbMlOTkPmA.png" /><figcaption>Image generated by AI</figcaption></figure><p>Because the usual version of this question (“is Vim dead now that AI writes the code?”) misses what Vim actually is. Let me explain.</p><h3>Vim is a grammar you learn once</h3><p>Most people think Vim is an editor with weird keybindings. That’s the surface. Underneath, modal editing is a composable language. You combine a verb with a motion and the two multiply. ciw changes a word, daw deletes a word and the space around it, d} deletes to the next blank line, and gg=G re-indents the whole file.</p><p>Once that clicks, you stop thinking in keystrokes and start thinking in sentences. “Change inside these parens.” “Delete three lines.” “Yank to the end of the function.” Your intent maps straight to a few keys.</p><p>What the Vim evangelists undersold is that the grammar outlives the editor. I use Vim motions in <strong>lazygit</strong> to stage hunks, in <strong>AeroSpace</strong> to throw windows around my screen, in less to page through logs, and in the normal mode my AI editor ships with. Learn the grammar once and it follows you into half the tools on your machine.</p><p>That’s the real reason it’s still around in 2026. It buys you leverage across your whole toolchain, and the editor is almost beside the point.</p><h3>How I actually run it in 2026 🛠️</h3><p>Let me get specific, because vague “Vim is great” takes are worthless.</p><p>I run <strong>LazyVim</strong> on top of Neovim. A few years ago I would’ve hand-wired a config from scratch in Lua, tuning every plugin myself. I don’t do that anymore. LazyVim gives me sane defaults, LSP and Treesitter wired up out of the box, and a sensible plugin set, so I just customize from there. It’s still Lua underneath, still version-controlled in my dotfiles, so a new machine or a fresh SSH box means I clone and I’m home in minutes.</p><p>Quick note for the gatekeepers: running a distro doesn’t make you “not a real Vim user.” It lowers the on-ramp, which is exactly what you want in an era where your time is better spent shipping than debugging your own plugin manager. Argue with your mama.</p><p>Then there’s the AI question, answered honestly. I don’t sit inside a chat window typing prompts and pasting code back out. <strong>OpenCode</strong> runs in the same terminal as my editor, so AI output lands in the buffer I’m already working in. No context-switch tax. When I need heavier agentic work, spinning up a feature or refactoring across files, I’ll reach for Claude Code or Cursor, then come back to Neovim to shape the result.</p><p>So it’s not Vim versus AI. The two do different jobs, and I use both for what each is good at.</p><h3>The honest tradeoff ledger</h3><p>If I’m selling you on the learning curve, you deserve both columns. Here’s where Vim still wins for me, and where I don’t pretend it does.</p><p><strong>Where Vim wins in 2026:</strong></p><ul><li>Raw editing speed on code that already exists. Refactors, surgical edits, reflowing a block, renaming across a function. This is where motions pay rent.</li><li>Ubiquity. Same muscle memory on my laptop, a client’s machine, or a server I SSH’d into at 2 a.m. No install ceremony, no “let me set up my editor first.”</li><li>Precision. AI generates code fast, and then you still have to review and reshape it. Moving through that code with intent beats clicking around.</li><li>Composability. Everything pipes into everything else in a terminal-native setup, and the editor is just one more link in the chain.</li></ul><p><strong>Where it loses:</strong></p><ul><li>Cold-starting an unfamiliar codebase. When I’m exploring a repo I’ve never seen, a GUI editor’s click-through discovery and visual navigation is genuinely faster.</li><li>Rich visual tooling. Step debuggers and some refactor-preview panels are nicer in <strong>VS Code</strong> or Cursor, and I’ll switch when I need them.</li><li>The learning curve is real. You’re looking at weeks before you’re faster than you were in your old editor, not days. If you ship for a living right now, price that ramp in.</li><li>Collaboration. Your 40-keystroke macro is invisible magic to whoever’s watching your screen share.</li></ul><p>A tool earns its spot by being honest about its edges. Vim’s edges are real. I keep it anyway, because the wins line up with how I actually spend my day.</p><h3>“But AI writes the code now, so why learn to edit fast?”</h3><p>This is the real objection in 2026, so let me meet it head-on.</p><p>AI moved the bottleneck. Two years ago the slow part was typing the code. Now the slow part is reading it, correcting it, and shaping it into something you’d put your name on. That work is cursor-heavy and precision-heavy. You’re jumping between definitions, rewriting a function the model got 80% right, tightening names, deleting the three helper functions it invented for no reason.</p><p>All of that is squarely Vim’s lane.</p><p>So the more code your assistant generates, the more time you spend navigating and surgically editing code you didn’t write. Fast, precise movement through a file became more valuable with AI in the loop. The devs who feel slow in the AI era are often the ones fighting their cursor while they review.</p><h3>Should you learn Vim in 2026?</h3><p>Here’s where I filter honestly, because this genuinely depends on who you are.</p><p><strong>Start now if:</strong> you live in the terminal, you SSH into servers, you want a setup that survives every IDE hype cycle, or you’re early in your career and building muscle memory that compounds for a decade. The payoff curve is long, so the earlier you start, the more you collect.</p><p><strong>Learn the motions, skip the religion:</strong> turn on Vim keybindings in <strong>VS Code</strong> or Cursor and stop there. You get most of the editing speed without the config rabbit hole, and honestly this is the right call for most working devs. If you do want the full Neovim experience without the setup grind, start with a distro like LazyVim so you’re productive in an afternoon instead of wrestling plugins for a week.</p><p><strong>Probably skip it if:</strong> you’re fast and happy in your GUI editor, you rarely touch a terminal, and your weeks are better spent on the actual craft. That’s a legitimate answer. Forcing Vim because it’s a flex is how you lose a month for no return.</p><h3>The verdict</h3><p>Vim earned its place on my stack, though I don’t treat it as dogma. In 2026 it’s a force multiplier sitting on top of my AI tooling, speeding up the half of the job that assistants made bigger: reviewing and shaping code.</p><p>And even if you never make Neovim your home editor, the grammar is worth learning. Flip on Vim mode in whatever you already use and give it two weeks. Worst case you bail, and you’ve lost a little time. Best case it follows you into every tool you touch for the rest of your career.</p><p>What’s your editor setup in the AI era, full Neovim, Vim mode in Cursor, or neither? Drop it in the comments, I’m always curious what’s actually working for people. 💡</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d94f92d9edde" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Skill That Argues With My Notes: How It Finds My Blind Spots]]></title>
            <link>https://medium.com/@hackastak/i-built-a-skill-that-argues-with-my-notes-how-it-finds-my-blind-spots-7c2f00875959?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c2f00875959</guid>
            <category><![CDATA[pkm]]></category>
            <category><![CDATA[second-brain]]></category>
            <category><![CDATA[obsidian]]></category>
            <category><![CDATA[critical-thinking]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-09-30T12:11:01.552Z</atom:updated>
            <content:encoded><![CDATA[<p>My <strong>Obsidian</strong> vault had become very good at proving me right. I could search almost any opinion and find years of notes ready to support it. That felt useful until I realized what the system was doing. It was making my existing beliefs easier to defend without making them more accurate.</p><p>So I built /challenge, a <strong>Claude Code</strong> skill that reads my notes and looks for the parts I would rather miss. It hunts for contradictions, hidden assumptions, weak reasoning, and strong perspectives I never considered.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mOiwhqEnnwzj1ZtDc38ScA.png" /><figcaption>Image generated by AI</figcaption></figure><p>A second brain should occasionally tell you that your first brain is wrong.</p><h3>Your Echo Chamber Starts Before the Vault</h3><p>Most personal knowledge management systems follow the same loop of capturing, organizing, retrieving, and reinforcing.</p><p>You read something interesting, save it, connect it to related notes, then retrieve it when the topic comes up again. Each pass makes the idea feel more established because the supporting material is easier to find. The bias often starts before anything reaches your notes.</p><p>Social feeds, video platforms, newsletters, and recommendation engines learn from what you click, watch, save, and share. Engage with one position often enough and the algorithm serves you more of it. That filtered stream becomes the raw material for your PKM system.</p><p>Now the loop has two layers. The platform narrows what reaches you, then your vault preserves and resurfaces the narrowed view. Search makes this worse in a subtle way. Ask, “What have I written about AI coding?” and it faithfully returns what you already captured. Ask an AI to summarize those notes and you get a more fluent version of the same information diet. That’s useful retrieval, but weak pressure-testing.</p><p>I wanted a command that asked a different question. “Where does my own evidence weaken this belief?”</p><h3>I Built a Mirror and a Critic</h3><p>I already had a skill called /ghost that answers questions in my voice. It reads my notes, extracts my stated beliefs and reasoning patterns, then drafts the response I would probably give. It’s a mirror. When I want a properly written paragraph or article that explains how I think in my own voice, /ghost makes my current position explicit enough to react to.</p><p>/challenge plays the critic. It takes that position and searches the same vault for reasons to doubt it.</p><p>The workflow is simple:</p><ol><li>Run /ghost [question] when the current belief is fuzzy.</li><li>Turn the answer into one clear claim.</li><li>Run /challenge [claim] against the vault.</li><li>Resolve the strongest contradiction or gather the missing evidence.</li><li>Record the decision and why the rejected alternative lost.</li></ol><p>The pairing matters because vague beliefs are hard to test. “I think consistency is important” can survive almost any criticism. “Publishing consistently matters more than topic selection” gives the critic something concrete to attack. That’s where the useful discomfort starts.</p><h3>How /challenge Reads My Vault 🛠️</h3><p>The skill begins by searching across Projects, Areas, Resources, Inbox notes, and Weekly Notes. It gathers every relevant position instead of trusting the first matching file.</p><p>Then it performs six passes.</p><ol><li><strong>Map the current position.</strong> What do I appear to believe, and which notes support it?</li><li><strong>Find contradictions.</strong> Where do two notes make claims that can’t both be true?</li><li><strong>Separate tensions from conflicts.</strong> Competing values, such as speed and quality, may represent a real trade-off rather than faulty reasoning.</li><li><strong>Expose hidden assumptions.</strong> Is the belief relying on universality, causation, recency, survivorship bias, or an untested prediction?</li><li><strong>Steelman the opposition.</strong> What would a smart person who disagrees say?</li><li><strong>Recommend the next check.</strong> What question, experiment, or outside evidence would make the decision stronger?</li></ol><p>The report follows a predictable structure.</p><pre># Belief Stress Test: [topic]</pre><pre>## Your Current Position<br>## Contradictions Found<br>## Hidden Assumptions<br>## Weak Points in Reasoning<br>## Missing Perspectives<br>## Questions Worth Sitting With<br>## Overall Assessment</pre><p>Every important finding points back to a source note. I can open the file, read the original context, and decide whether the criticism holds. The command is also read-only. It doesn’t rewrite my notes or make the decision for me. Its job is to make weak reasoning visible before I commit to it.</p><h3>Why I Don’t Just Ask AI to Debate Me</h3><p>I could open a blank chat and type, “Argue against this idea.” I’ve tried that. The result is usually a competent list of generic objections that could apply to almost anyone.</p><p>A vault-grounded challenge is harder to dismiss because it uses my own receipts. It can show that a principle in one project conflicts with a shortcut I accepted in another. It can compare a confident prediction from a weekly note with the result recorded three months later. It can find the trade-off I acknowledged when discussing somebody else’s system and quietly ignored when evaluating my own.</p><p>That context changes the quality of the disagreement. A generic debate partner invents possible weaknesses. /challenge starts with weaknesses already present in my history. It also keeps the criticism proportional. The goal is useful pressure, because constant contrarianism becomes another kind of noise. The report distinguishes a direct contradiction from a tension, a missing fact, or a reasonable assumption that simply needs monitoring.</p><p>That makes the output easier to act on. I can revise a claim, gather one missing data point, or document why I’m accepting a known trade-off. The disagreement ends in a better decision instead of an endless debate.</p><h3>The Belief That Failed the Test</h3><p>I gave /challenge a belief that had already appeared in my vault.</p><blockquote><em>Publishing consistently matters more than topic selection.</em></blockquote><p>The belief had a reasonable origin. A weekly cadence builds a body of work, creates momentum, and removes the recurring debate about whether to publish. I had even described “consistency beats topic selection” as an idea worth developing. Then /challenge compared that position with the performance data in my blog strategy.</p><p>The first contradiction was immediate. I had published on a consistent cadence, but individual posts ranged from 6 views to 2.7K views. If consistency was the dominant variable, results from the same schedule shouldn’t have varied by roughly 40 times. The command also surfaced a hidden assumption. I was assuming Medium rewarded frequency strongly enough to smooth over differences in topic and framing. My notes contained no evidence for that. The distribution numbers pointed the other way.</p><p>Then came the missing perspective. Medium’s presentation data was direct market feedback. The concrete, first-person pieces built around named tools and real systems received the strongest distribution. <em>10 CLI Tools That Replace Your GUI in 2026</em> reached 2.7K views. <em>Claude Code + Obsidian: How I Built an AI-Powered Second Brain</em> reached 798. My weekly-notes article reached 462.</p><p>Abstract AI and career commentary published on the same cadence landed between 1 and 15 views. The sharpest question in the report was also the simplest.</p><blockquote><em>If consistency is the main lever, why did equally consistent posts produce radically different outcomes?</em></blockquote><p>I couldn’t defend the old claim after that. The corrected position in my strategy is more useful. Consistency keeps the blog eligible, while topic and framing dominate distribution. I now prioritize concrete, personal, tool-specific posts and use a pillar rotation to preserve variety.</p><p>The original idea was directionally useful but too broad. /challenge forced the nuance that retrieval alone had missed.</p><h3>Build the Smallest Useful Version</h3><p>You don’t need my entire vault setup to try this. You need a folder of markdown files and an AI agent that can read local files. You can also do this with a cloud notes application setup as long as the provider you are using provides an API layer that you can connect your agent harness to.</p><p>Start with this prompt.</p><pre>Read every note relevant to [belief].<br>State my current position with citations.<br>Find direct contradictions, hidden assumptions, weak reasoning,<br>and missing perspectives. Steelman the strongest opposing view.<br>Separate factual conflicts from legitimate trade-offs.<br>End with questions and the evidence I should gather next.<br>Do not edit any files.</pre><p>Give the agent a short instruction file that explains your folder structure and tells it where to search. Require citations to the original notes, and keep the first version read-only. That last part is important. A challenge system should show its work. If it claims two notes conflict, you should be able to inspect both passages and decide whether your thinking changed over time or whether a real contradiction remains.</p><p>Once the basic prompt works, save it as a reusable skill or command. Mine lives in the open-source <a href="https://github.com/hackastak/staksmith">Staksmith repository</a>, so you can copy the full /challenge definition and adapt the search paths to your own system.</p><h3>Your Vault Can Still Fool You</h3><p>Adversarial retrieval improves the system, but it can’t manufacture perspectives you never captured. If every source in your vault came through the same recommendation loop, /challenge is still working with one-sided material. It may notice repeated assumptions or missing evidence, but it can’t reliably reconstruct an entire position that never entered the system.</p><p>That’s why “missing perspectives” is one of the most valuable sections in the report. It tells me when the next step belongs outside the vault. Sometimes I need primary documentation. Sometimes I need customer interviews, performance data, or a small experiment. Sometimes I need to read the strongest person who disagrees with me instead of another article that confirms the position.</p><p>The model can also misread evolution as contradiction. A note from two years ago and a note from last week may disagree because I learned something. Dates and context matter.</p><p>Citations help, but they don’t remove the need for judgment. I open the source notes before accepting any important finding.</p><h3>The Decision Ritual I Use Now 💡</h3><p>Before a consequential decision, I write the belief in one sentence. If I can’t state it clearly, I run /ghost first. Then I give the explicit claim to /challenge and focus on the strongest contradiction, not the longest list of minor objections.</p><p>From there, I choose one of three actions.</p><ul><li>Revise the belief because my own evidence already disproves it.</li><li>Gather external evidence because the vault is incomplete.</li><li>Keep the belief and record why the counterargument didn’t survive scrutiny.</li></ul><p>This creates a deliberate pause before commitment. I remain the authority, but the process makes me earn confidence instead of borrowing it from a large pile of familiar notes. My vault can still act as a filing cabinet or a mirror when I need one. Now it can also become a sparring partner.</p><p>Stored knowledge gets more valuable when it can resist you.</p><p>What belief would you ask your own notes to challenge first?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c2f00875959" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PR Reviews: Why Reading Someone Else’s Code Made Me a Better Engineer]]></title>
            <link>https://medium.com/@hackastak/pr-reviews-why-reading-someone-elses-code-made-me-a-better-engineer-71ea2d3fdfdc?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/71ea2d3fdfdc</guid>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[professional-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 23 Sep 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-09-23T12:11:01.492Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The fastest engineering lessons in my week usually start in someone else’s code</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_55uwopoLIMKf6VFo0LOBg.png" /><figcaption>Image generated by AI</figcaption></figure><p>Most Mondays, I open <strong>GitHub</strong> and find a line of pull requests waiting before I’ve written any code. I used to see that queue as work standing between me and my real work. Then reviewing became a weekly habit.</p><p>One implementation arrived as seven separate PRs. Another week, I approved or closed eight PRs across several related codebases. After a few weeks of that rhythm, I was learning more from reading someone else’s code than from writing more of my own.</p><p>Writing code exercises the decisions you already know how to make. Reviewing exposes you to decisions you might never make on your own. That changed how I think about becoming a better engineer. 💡</p><h3>Writing More Code Eventually Repeats the Same Lessons</h3><p>Developers improve by building things. But when you own the implementation, you also choose the architecture, abstractions, libraries, and compromises. Even difficult work gets filtered through your existing instincts.</p><p>A pull request takes away that control. Someone else framed the problem and chose the boundaries. Your job is to reconstruct their reasoning from the change and decide whether it holds up.</p><p>Writing tests whether your solution works. Reviewing tests whether you understand why a different solution works, where it might fail, and what it could cost later. That loop strengthened five skills faster than another round of solo coding.</p><h3>1. I Learned to See Architecture Across Changes</h3><p>The seven-PR feature was the clearest example. Each PR covered one slice of a larger implementation. Any slice could look clean on its own, but I had to understand how all seven combined. Where did data enter? Which layer owned each responsibility? Did an early shortcut create coupling three PRs later?</p><p>When you build the feature, that architecture already lives in your head. A reviewer has to rebuild the mental model from the evidence in front of them. Clean files can still combine into a system that’s hard to change. The real test is whether locally sensible decisions form a coherent whole.</p><p>I now review the larger flow as deliberately as each diff. 🛠️</p><h3>2. I Built a Bigger Pattern Library</h3><p>Reviewing across several codebases exposed me to more variety than staying inside one repository. Every unfamiliar PR added examples of dependency boundaries, error handling, API design, tests, and failure modes.</p><p>Strong changes gave me patterns worth reusing. Awkward changes showed me which decisions create friction. Even dependency updates taught me to separate harmless maintenance from changes that needed deeper regression testing. Repetition turns “something feels wrong” into actionable feedback. You can name the smell, explain the consequence, and suggest a smaller alternative without redesigning the feature.</p><p>That pattern library follows you back into your own work. I keep short notes on approaches worth stealing and mistakes worth avoiding.</p><h3>3. I Learned to Ask Better Questions</h3><p>Most of the seven sliced PRs were good. A couple needed clarification before I could approve them. Sometimes the implementation is wrong. Sometimes the reviewer is missing context. A good question reveals which one you’re dealing with.</p><p>“I don’t like this approach” gives the author almost nothing to work with. “What guarantees that this state is still valid when the next slice runs?” identifies the assumption you need to verify.</p><p>The questions that produce the best reviews usually focus on consequences:</p><ul><li>What assumption does this code depend on?</li><li>What happens when the dependency fails or returns partial data?</li><li>Is this behavior covered at the right boundary?</li><li>Does this abstraction simplify the next change or only this one?</li><li>Is the complexity inherent to the problem, or did the implementation introduce it?</li></ul><p>Specific questions make the review collaborative and expose gaps in your understanding before a preference becomes a blocking comment. They’ve also improved how I communicate outside GitHub. I spend less time proposing immediate solutions and more time identifying the risk that needs discussion.</p><h3>4. I Learned the Product Behind the Code</h3><p>The more PRs I reviewed, the more involved I became in the product. Reviews led to conversations about how the codebases fit together, where the product was going, and which decisions mattered beyond the current ticket.</p><p>Implementation details reveal constraints that task descriptions hide. You see where services depend on each other, which workflows are fragile, and where a small change creates operational work somewhere else. My review questions started changing.</p><p>“Is this code clean?” still mattered, but it became one part of a larger evaluation:</p><ul><li>Does this behavior match what the user or partner needs?</li><li>Is the operational cost worth the implementation convenience?</li><li>Are we preserving an old constraint that no longer applies?</li><li>Can the team support this after launch?</li></ul><p>Engineering growth means connecting code-level decisions to product, operations, and team consequences. Before I get deep into a diff, I state the outcome the PR should create. If I can’t, I don’t understand it well enough to review it.</p><h3>5. I Developed Judgment Without Owning Every Decision</h3><p>Reviewing lets you watch different engineers decompose problems, accept complexity, and choose which tradeoffs feel safe. Then you have to decide what deserves a comment, what deserves a blocking request, and what is simply different from how you would have written it.</p><p>Weak reviews turn preferences into requirements. Strong reviews protect the codebase without forcing every contributor to think the same way. You can’t give every concern equal weight. A production failure matters more than a naming preference. A missing authorization check matters more than a helper function you would have extracted differently.</p><p>Approving is also a decision. Repeated reviews gave me practice making those calls with incomplete information, and you don’t need to own every implementation to develop that judgment.</p><h3>The PR Review System I Use</h3><p>Volume alone won’t make you a better reviewer. Skimming 20 diffs teaches less than carefully reconstructing two important changes. I use five steps.</p><ol><li><strong>Triage the queue.</strong> High-impact changes come before routine updates. Quick approvals shouldn’t hide the architectural change that needs uninterrupted attention.</li><li><strong>Read for intent.</strong> Identify the problem, expected outcome, and scope before getting lost in individual lines. Ask when the PR description leaves context out.</li><li><strong>Review in passes.</strong> Start with architecture and scope, then check correctness and failure modes, and finish with tests, maintainability, and naming.</li><li><strong>Leave actionable comments.</strong> Name the concern, explain the consequence, and ask a question or suggest the smallest viable alternative. Mark optional feedback as optional.</li><li><strong>Close the loop.</strong> Revisit responses. When the same comment keeps appearing, move that guidance into documentation, tooling, or a team standard.</li></ol><p>The best review comment is sometimes the last time anyone needs to write that comment manually. ✨</p><h3>You Can Practice This Without a Review Queue</h3><p>You can practice this as a solo developer or before your first engineering role.</p><ul><li>Review open PRs in an open-source project you already use.</li><li>Compare your observations with the maintainer feedback after the PR moves forward.</li><li>Review a friend’s side project and ask them to explain decisions you don’t understand.</li><li>Open a merged PR in a mature repository, inspect the diff first, and predict the concerns before reading the real conversation.</li></ul><p>Start with two or three PRs per week. Don’t manufacture comments to prove you participated. A clean approval with a clear reason is more valuable than five low-signal suggestions.</p><h3>Read More Code Than You Write This Week</h3><p>The Monday queue still represents real work, but I no longer see it as time taken away from growth. Reviewing taught me to see architecture, build a wider pattern library, ask better questions, understand the product, and make clearer decisions about risk.</p><p>Before you start your next project, review three pull requests. Write down one architectural decision, one unfamiliar pattern, and one question each review forced you to answer.</p><p>The fastest way to become a better engineer might be opening the queue on Monday and learning how someone else thinks.</p><p>What could you learn by reviewing three pull requests this week?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71ea2d3fdfdc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Prompt to Product: When Prompting Becomes Engineering]]></title>
            <link>https://medium.com/@hackastak/from-prompt-to-product-when-prompting-becomes-engineering-83be48c6a432?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/83be48c6a432</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 16 Sep 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-09-16T12:11:01.443Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part 3 of Demystifying Prompt Engineering</h4><p><a href="#">Part 1</a> gave us the mental model. The LLM finishes documents. <a href="#">Part 2</a> used it to write a better single prompt. This part is about everything after the single prompt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oOM-FyvBoyt68AmRS1Eqfw.png" /></figure><p>Because the demo always works. You craft one clever prompt, it nails the example you tried, and for a second it feels like magic again. Then you wire it into something real, whether a feature, an agent, or a pipeline, and it falls over in ways your demo never showed.</p><p>The fix isn’t a better prompt. It’s treating the model for what it is. It’s powerful, fast, and fundamentally <strong>undependable,</strong> but you don’t argue it into reliability. You build the system around it. Here’s what that takes. 💡</p><h3>1. Let it think before it answers</h3><p>The model has no inner monologue. Ask a hard question and it blurts the first plausible continuation, with no scratch work, no “let me reason this through,” just an instant guess. And an instant guess on a multi-step problem is usually wrong. Now, some models do have advanced thought, where it tests the first plausible continuation against other things it knows to be true instead of just taking it and outputting it as the answer outright.</p><p>So give it room to think <em>out loud, in the output.</em> This is <strong>chain of thought</strong>, and it’s almost embarrassingly simple. Ask the model to work through its reasoning before giving the final answer. Even a plain “let’s think step by step” measurably bumps accuracy on anything with moving parts. The reasoning is the model doing the work it can’t do silently.</p><p>The grown-up version is <strong>ReAct</strong>, short for <em>reason + act.</em> The model alternates between thinking and <em>doing</em>. It thinks about what it needs, takes an action (search, look something up, call a tool), observes the result, and thinks again. It’s how you get from “answer from memory” to “go find out, then answer.” For anything that needs facts the model doesn’t already have, that loop is the difference between confident fiction and a real answer.</p><p>Here’s the rule of thumb. If a problem has more than one step, make the model show the steps. 🛠️</p><h3>2. Tools without tears</h3><p>A bare model is trapped in its own head. It can’t look up today’s data, can’t do reliable math, can’t <em>do</em> anything in the real world. Tools fix that. You tell the model what’s available, it decides when to call one, and your application runs the actual function and feeds the result back.</p><p>Here’s the thing nobody tells you. A tool definition is a prompt. The model reads your function names, descriptions, and arguments the same way it reads everything else. So write them for a <em>human</em> to understand:</p><ul><li><strong>Name things clearly.</strong> getUserEmail reads; retrieveemail doesn&#39;t. The model leans on names that look like code it&#39;s seen.</li><li><strong>Keep arguments few and simple.</strong> The more arguments, and the fancier their types, the more the model fumbles, including inventing argument values that were never there. (Yes, it hallucinates function arguments. Same root cause as everything else.)</li><li><strong>Don’t paste your whole API in.</strong> Too many tools and the model gets confused about which to reach for. Give it a small, clean set that covers the job.</li></ul><p>And one hard line. <strong>Never trust the model to gate a dangerous action.</strong> “Ask the user before deleting anything” <em>will</em> fail some fraction of the time, because the model is undependable by nature. Don’t make it a rule in the prompt, make it a wall in your code. Intercept the destructive tool call and require a real human sign-off before it runs. The model can suggest; your application decides.</p><h3>3. Agents vs. workflows: know which one you’re building</h3><p>When one prompt isn’t enough, people reach for an “agent,” handing the model some tools and a goal and letting it figure out the rest. Sometimes that’s right. Often it’s not.</p><p>There’s a real fork here:</p><ul><li>A <strong>workflow</strong> is a fixed path you design, where step one feeds step two feeds step three. Rigid, but <em>strong</em>, because you’ve encoded the structure. Reach for it when the job is specific and repeatable.</li><li>An <strong>agent</strong> decides its own path at runtime. Flexible, but weaker and less predictable. Reach for it only when the path genuinely can’t be known ahead of time.</li></ul><p>Most “agent” projects should’ve been workflows. If you know the steps, <em>encode the steps</em>, and don’t make the model rediscover them on every run and hope it gets there.</p><p>Two principles keep these systems sane, both straight from the people who built Copilot:</p><ul><li><strong>Whenever you can avoid using an LLM, do so.</strong> A web crawler, a database write, a plain old classifier. If regular code can do a step reliably and cheaply, use regular code. Save the model for the parts that actually need language.</li><li><strong>Confine the LLM to small, well-defined tasks</strong>, then wire those tasks together with ordinary, deterministic plumbing. When something breaks, and it will, you want to isolate the failure to one task, not debug a mysterious blob of “the agent did something.”</li></ul><p>The pattern that scales is boring, predictable structure on the outside, with the model doing one clear job at each node on the inside.</p><h3>4. Write the eval first</h3><p>This is the one everyone skips, and it’s the one that actually separates a toy from a product.</p><p>You cannot improve what you can’t measure. Change a prompt and the output <em>looks</em> different. Better? Worse? You genuinely can’t tell from eyeballing one or two runs, because the model’s nondeterministic and your gut is biased toward the version you just wrote. The team behind Copilot put it bluntly. The <em>first</em> thing they built was the evaluation, and it’s the only reason they could move fast without breaking things.</p><p>You don’t need a research harness on day one. Start tiny:</p><ul><li><strong>An example suite.</strong> Five to twenty representative inputs, a script that runs your prompt against all of them, and a way to diff the results. That’s it. The moment you can see all your outputs side by side, the typical failure modes jump out.</li><li><strong>Grade on the aspect that matters.</strong> Exact-match is usually too strict for free-form output, so check the thing you actually care about, like whether the support bot resolved the issue, not whether it phrased things word-for-word like your gold answer.</li><li><strong>You can let a model grade, but carefully.</strong> LLM-as-judge works, but never let a model grade its <em>own</em> output, and never tell it it’s grading itself, because that invites every bias you’d expect. Structure the grading. Ask <strong>specific</strong> questions, on a defined <strong>scale</strong> (say 1 to 5 with each level described), across the <strong>separate aspects</strong> you care about. Precise questions force more objective answers.</li></ul><p>Offline evals like this let you kill bad ideas cheaply, before they ever touch a user. The good ones graduate to a real test against live traffic.</p><h3>The whole series in one line</h3><p>Three parts, one arc. The LLM finishes documents <em>(Part 1).</em> So write it a clean one <em>(Part 2).</em> And when one document isn’t enough, wrap it in a system that reasons, uses tools carefully, stays mostly deterministic, and measures itself <em>(Part 3).</em></p><p>Notice what happened to the magic along the way. It didn’t survive contact with any of this. A document-completion engine, curated context, deterministic plumbing, and an eval suite add up to plain engineering. And that’s the good news, because engineering is <em>learnable.</em> You don’t need the secret prompt. You need the mental model and the habits, and now you’ve got both.</p><p>If you want the full, unabridged version of all this, the book this series distills is genuinely worth your time. It’s <em>Prompt Engineering for LLMs</em> by John Berryman and Albert Ziegler. These three articles are the map. The book is the territory. ✨</p><p><strong>You’ve now got the whole framework, so which part are you putting to work first? Tell me what you’re building, and where the model’s been fighting you.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=83be48c6a432" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Weekly Review Writes Itself: Git Commits + Vault Tasks Into a Finished Weekly Note]]></title>
            <link>https://medium.com/@hackastak/my-weekly-review-writes-itself-git-commits-vault-tasks-into-a-finished-weekly-note-39dceb1f0ac7?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/39dceb1f0ac7</guid>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[obsidian]]></category>
            <category><![CDATA[weekly-review]]></category>
            <category><![CDATA[pkm]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 12:11:01 GMT</pubDate>
            <atom:updated>2026-09-09T12:11:01.202Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The weekly review is the first habit to die. Here’s the one command I run when I close out Friday that drafts mine from the week’s commits and closed tasks, so I show up to edit instead of starting from a blank page.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h2bxeFyo_RMo7k18T5rPFw.png" /><figcaption>Image generated by AI</figcaption></figure><p>It’s Friday, 5 PM. Your brain is fried, the week is already a blur, and your weekly note is a blank page waiting for you to reconstruct five days from memory.</p><p>So you skip it… again.</p><p>The one habit that would actually make next week better is the one you never have any energy left for.</p><p>Mine doesn’t get skipped anymore, because by the time I sit down to review, the draft is already written. One command reads what I jotted during the week, pulls my commits and closed tasks, and hands me a finished weekly note to edit. 💡</p><p>I still do the thinking. I just don’t do the typing.</p><h3>Why the Weekly Review Always Dies</h3><p>The weekly review has the best return of any habit in a multi-project life. It’s also the first one you drop the second you get busy. That’s backwards, and it’s worth understanding why.</p><p>The problem is that writing it is manual, and it lands at the worst possible moment. Friday evening, when you’re most drained, is exactly when you’re asked to remember what you shipped on Monday.</p><p>And you don’t remember. Not really. Half the wins evaporate, the small decisions blur together, and the blocker you hit Wednesday feels like it happened last month.</p><p>Discipline was never the problem here. The timing is brutal and the blank page is intimidating, so the habit quietly dies while you tell yourself you’ll do it next week.</p><h3>Automate the Gathering, Keep the Thinking</h3><p>Here’s the reframe that saved mine. A weekly review is really two jobs wearing one hat.</p><p>The first job is gathering and reconstructing what happened. Which repos you touched, what you shipped, which tasks you closed, where you got stuck. It’s pure bookkeeping, and it’s the part that eats your Friday energy.</p><p>The second job is judgment, so deciding what it all meant and what you’re going to do differently next week. That’s the part that actually matters, and it’s the part only you can do.</p><p>So automate the bookkeeping, not the thinking. Let a script reconstruct the week while you bring the judgment. That single split is the whole system, and everything below builds on it.</p><p>One nuance before we go further. My git history matters less here than you’d think. The richest input is the quick notes I jot each day. That daily capture is thinking I do live, in thirty-second bursts. The tool never invents it. It synthesizes what I already noticed. 🛠️</p><h3>What It Actually Produces</h3><p>Before the build, look at the payoff. When I run it, I get a finished six-section report dropped straight into my weekly note. Here’s a real one from a recent week, lightly redacted:</p><pre>## Highlights<br>- Published a new article and wired it to my first Gumroad product<br>- Rebranded ProtoFlow and shipped a 3D model viewer + a tabbed pricing page<br>- Cleared a 7-PR review backlog on a client platform</pre><pre>## Summary</pre><pre>Content and products: the biggest content week of the quarter. Shipped the<br>article midweek and bootstrapped the blog-to-product funnel by listing the<br>product and linking it from the piece. Spent a session mapping out more<br>products that could ride the same pattern.</pre><pre>ProtoFlow: four commits, all marketing-site. A rebrand, a 3D viewer in the<br>hero section, and a pricing page refactored into tabbed categories.</pre><pre>Client work: reviewed 7 sliced PRs, most clean, a couple needed a<br>clarification, and coordinated on locking down versioning before a<br>production launch.</pre><pre>## Blockers &amp; Challenges<br>- WIP piling up. One repo has 39 uncommitted changes sitting locally, and<br>  that context gets more expensive to recover the longer it waits.</pre><pre>## Metrics<br>- Commits: 4<br>- Articles published: 1<br>- Products listed: 1<br>- PRs reviewed: 7<br>- Active project areas: 5</pre><p>The full report runs six sections. Highlights, a Summary broken down by project area, Learning and New Ideas, Blockers and Challenges, Metrics, and a Changelog of commits grouped by repo.</p><p>Now look at that Summary again, because it’s the tell. None of it came from my commits. The rebrand story, the funnel note, the versioning work, the 39-file backlog I’d been quietly ignoring, all of it got reconstructed from three-line daily bullets I’d half-forgotten I wrote. The narrative sections come from my daily notes. The Metrics and Changelog come from the git and task scan. The story is only as good as the notes I kept during the week, which turns out to be the whole point.</p><h3>The Build: How It Actually Works</h3><p>Start with the input, because it’s what makes everything else possible.</p><p><strong>The daily journal is the fuel.</strong> Through the week I drop quick bullets under each day in the weekly note. A meeting, a decision, a thing I shipped, a blocker I hit. Thirty seconds, not an essay. That running capture is the human half of the system.</p><p>If you skip it, the automation still runs, but the narrative comes out thin. Notes in, story out.</p><p>Then the Friday run does three things. I use a <strong>Claude Code</strong> skill for this, but I’ll describe each step so you can build a lighter version yourself.</p><p><strong>Phase 1: discover and scan the repos.</strong> Instead of hardcoding a repo list, the tool reads my daily notes for the projects I actually mentioned that week, then scans just those repos for my commits, uncommitted changes, and active branches. The reader-buildable version is one line of <strong>Git</strong> you probably already know:</p><pre>git log --author=&quot;you&quot; --since=&quot;1 week ago&quot; --pretty=format:&quot;- %s&quot;</pre><p>That’s the same pattern that already lives in my weekly-note template, so the raw material was there before any automation existed.</p><p>A quick note on making discovery reliable, then I’ll move on. The scan finds a project two ways, from an [[wikilink]] or a single-word Label: at the start of a bullet. So a two-second tag while you journal is what lets the machine group your week for you. Tag a project with [[repo-name]] and the scan picks it up automatically. Just keep labels to a single word (RepoG: works, Repo Genie: won&#39;t, so use a wikilink for anything multi-word), and don&#39;t bother tagging work areas that aren&#39;t real repos. Beyond that, don&#39;t over-engineer it. Freeform prose still gets read.</p><p><strong>Phase 2: scan the vault tasks.</strong> The tool parses the tasks I closed in the last 7 days and the ones still open, grouped by project. In <strong>Obsidian</strong>, you can get most of this with a single Tasks query:</p><pre>done after -7 days</pre><p><strong>Phase 3: synthesize and merge.</strong> This is where <strong>Claude</strong> weaves the daily notes, the commits, and the tasks into the six sections, then writes the result into the weekly note. It only touches the report section and never overwrites what I wrote by hand. The daily bullets become the narrative, the commits and tasks become the metrics and changelog.</p><h3>One Command, Run on Purpose</h3><p>You might expect the next step to be a cron job that fires this every Friday at 5. I tried that idea in my head and decided against it, on purpose.</p><p>A scheduled job runs whether or not the week is actually done, and it drafts a review for a moment when I’m not there to read it. So I run it by hand when I close out for the week. The report reflects a finished week, and the act of running it becomes the first beat of the review instead of a background chore I’ll ignore.</p><p>What makes this a habit that survives is simple. The tedious part collapses to a single command, so even a wrung-out Friday can’t talk me out of it.</p><h3>The Read: What I Do the Moment It Finishes</h3><p>The command finishes in a few seconds, and then the real work starts. This is the part I’d never hand to a machine.</p><p>I read the draft top to bottom. I get an honest picture of the week while it’s still fresh. Then I decide what next week needs, what to cut, and which blocker I’ve been avoiding.</p><p>The report is a first draft. The review is what I do to it. Automating the gathering is exactly what gives me the time and the calm to actually think, instead of burning my last Friday hour reconstructing a changelog from memory.</p><h3>The Rhythm, Start to Finish</h3><p>Put the whole thing together and a week looks like this.</p><p>Monday through Friday, I drop a few bullets into the daily journal as things happen. A PR I reviewed, a feature I shipped, a decision I made, a wall I hit. It’s the kind of note that takes longer to feel guilty about skipping than to actually write.</p><p>Friday, when I close the laptop, I run the one command. A few seconds later the six sections are sitting in my weekly note, stitched together from those bullets, my commits, and the tasks I checked off.</p><p>Then I read. Fifteen minutes, tops. I trim whatever the synthesis over-weighted, sit with the blockers, and set two or three priorities for the week ahead.</p><p>That’s the entire loop. The capture is cheap and spread across the week, the gathering is automated, and the judgment is fifteen focused minutes on a Friday, spent on a document that already exists.</p><h3>Start Smaller Than Mine</h3><p>I run this across a couple dozen repos, but you don’t need anything close to that. If you’re earlier in your career, this scales all the way down.</p><p>Start with the habit. The automation comes later. Keep a daily journal in your weekly note, even just three bullets a day, and that capture pays off on its own before you script a single thing.</p><p>From there, the minimum viable version is honest copy-paste. Run the Git one-liner for your one active repo, drop the Tasks query at the top of your note, and paste the results in by hand on Friday. Do that for a month. Once it proves its worth, automate the gathering so you never have to remember the commands again.</p><p>A daily journal plus one repo plus one project’s task list is already a real weekly review. Everything I’ve built is just that same loop with more repos bolted on.</p><h3>What Breaks</h3><p>A few honest caveats, because the tool isn’t magic.</p><p><strong>Skip the daily journal and the narrative goes thin.</strong> The Highlights and Summary are only as good as the bullets you kept. Miss a week of journaling and you get accurate metrics wrapped around an empty story.</p><p><strong>Commits aren’t accomplishments.</strong> A green contribution graph can hide a busy-nothing week, and a huge refactor can look like one line. This is exactly why the judgment stays human. The machine counts, you weigh.</p><p><strong>Watch your author name.</strong> If the name in the scan doesn’t match your git config, it silently returns zero commits and you&#39;ll think you did nothing all week. First thing to check.</p><p><strong>Mind what leaves the room.</strong> If you point this at work or client repos, be deliberate about what lands in a synced vault. Keep private repo names and details out, or scope the scan to your own projects.</p><h3>Your Turn</h3><p>So here’s the question worth sitting with. What’s the one habit you keep dropping the second a week gets busy?</p><p>That’s the one to automate the gathering for first. Automate only the tedious reconstruction that makes you avoid it, and keep the thinking for yourself.</p><p>Tell me in the comments what habit you’d rescue, and I’ll help you figure out the one script that would keep it alive. ✨</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39dceb1f0ac7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Side Project Empire, Part 3: Turning Side Projects Into Income]]></title>
            <link>https://medium.com/@hackastak/side-project-empire-part-3-turning-side-projects-into-income-996b039a40cc?source=rss-1a52e10d7d73------2</link>
            <guid isPermaLink="false">https://medium.com/p/996b039a40cc</guid>
            <category><![CDATA[side-project]]></category>
            <category><![CDATA[passive-income]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[entrepreneurship]]></category>
            <dc:creator><![CDATA[Hunter Wiginton]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 14:20:33 GMT</pubDate>
            <atom:updated>2026-09-02T14:20:33.452Z</atom:updated>
            <content:encoded><![CDATA[<p><em>You picked projects that compound. You automated the busywork. Now here’s how the whole thing starts paying you back.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HfMrfppgX4HvV0E3WED1bA.png" /><figcaption>Image generated by AI</figcaption></figure><p>There’s a fantasy the internet sells developers, and I bet it sounds all to familiar. Quit your job, launch a startup, get rich while you sleep.</p><p>I’m not going to sell you that, because I’m not living it, and neither is almost anyone posting screenshots of their MRR dashboard.</p><p>Here’s what I am living. I still have a full-time job. I still have 15 side projects. And somewhere in the last few months, a couple of those projects quietly started making money, without me launching a company, raising a round, or working a single extra weekend to make it happen.</p><p>The income came from a loop I ran on top of the projects I already had, no new project required. 🛠️</p><p>This is Part 3, the last part of the series. Part 1 was about picking projects that compound. Part 2 was about the automation stack that lets one person run all of them. This part is about the payoff, and how you turn a portfolio of side projects into a trickle of income that grows as you keep shipping.</p><h3>Income Is a Side Effect, Not a Goal</h3><p>Let me be honest about the scale first, because the brand runs on honesty.</p><p>I have two products live right now. One is priced at $3. The other is $12. I’m early, and I’m not going to pretend a screenshot of life-changing revenue exists when it doesn’t.</p><p>So why write this at all? Because the <em>loop works.</em> I’ve run it twice, back to back, and both times it produced a real product with real buyers off the back of an article I was going to write anyway. Once you’ve proven a loop runs, running it fifty more times is a scheduling problem, not a mystery.</p><p>That’s the reframe for this whole piece. You’re not chasing a payday. You’re installing a repeatable motion that turns work you already do into products that sell while you’re doing something else. Income becomes a side effect of consistent shipping.</p><p>Back in Part 1, trait number seven was <em>content generation</em>, the idea that the right projects spin off blog posts, demos, and artifacts as a byproduct. In Part 2, I called the automation stack an <em>asset factory.</em> This part is where you sell what the factory makes.</p><h3>The Loop: 5 Stages</h3><p>Here’s the whole system in one line: <strong>byproduct → free article → packaged product → cross-link → repeat.</strong></p><p>Five stages. None of them require you to become a marketer or a founder. Let me walk each one, with the two real products I ran through it.</p><h3>1. Start With the Byproduct, Not a Product Idea</h3><p><strong>What it is:</strong> You don’t brainstorm a product. You look at what your projects already produced and ask which piece a stranger would pay for.</p><p>Most people do this backwards. They dream up a product, then try to build an audience for it from zero. You already skipped that step by building in public across a compounding portfolio.</p><p>My first product, the <strong>SDD Template</strong>, was a specification-driven-development template I’d built for my own projects months earlier. It already existed. I used it every time I started a feature. Packaging it took an afternoon, not a sprint.</p><p><strong>Why it works:</strong> A byproduct has already survived contact with reality. You use it, so you know it’s good, and you’ve already found its rough edges. That’s trait number one from Part 1, personal pain, showing up again on the money side. If you dogfood it, you can sell it.</p><h3>2. Teach It for Free</h3><p><strong>What it is:</strong> Write the article that gives away the thinking behind the byproduct. The whole thing. No paywall, no “get the rest for $9.”</p><p>This feels backwards too. If I’m giving it away, who buys? The answer is that the free article is what earns the trust that makes the sale possible, and it does the reaching that a product page never could.</p><p>When I listed the SDD Template, I paired it with an article on why test-driven development so often has people building the wrong thing first. The article stands on its own. You could read it, never buy anything, and still walk away with something useful. That’s the point. The template is just the shortcut for the readers who’d rather not build it themselves.</p><p><strong>Why it works:</strong> On <strong>Medium</strong>, the article is the distribution. It’s the thing the algorithm surfaces, the thing that gets shared, the thing a stranger finds at 11pm while stuck on the exact problem you solved. The product page can’t do any of that. The article is the top of the funnel, and it’s free because free is what travels.</p><h3>3. Package the Paid Version</h3><p><strong>What it is:</strong> Turn the raw byproduct into something a buyer can use in five minutes. Clean it up, write a README, explain how to install it, zip it, done.</p><p>This is the stage people over-engineer. You don’t need a landing page framework or a checkout funnel. My second product, the <strong>AI-Powered Second Brain Toolkit</strong>, was 8 <strong>Claude Code</strong> commands I already used on my own vault, bundled with a starter config file and a readme that explains setup for both <strong>Obsidian</strong> and plain Markdown. That’s it. Priced at $12.</p><p>I keep a short internal checklist for this so I’m not reinventing the packaging each time (core files, a README with a five-minute quick start, a changelog, a zip). <strong>Gumroad</strong> hosts the file and handles the payment. There’s no infrastructure to run.</p><p><strong>Why it works:</strong> The gap between “a thing I use” and “a thing you can use” is smaller than it looks, and closing it is the entire value you’re charging for. People are paying to skip the assembly. The knowledge itself was already free in the article.</p><h3>4. Link the Two</h3><p><strong>What it is:</strong> The article links to the product. The product links back to the article and the rest of your work. This single cross-link is the actual money mechanism, so don’t leave it out.</p><p>It sounds too simple to matter, but it’s the whole game. The free article does the reaching, builds the trust, and hands the reader a one-click path to the paid shortcut at the exact moment they want it. Skip the link and you’ve written a nice article that sells nothing.</p><p>When the second-brain article went out, it linked straight to the toolkit. Readers who wanted the commands didn’t have to rebuild them from the post. They clicked, paid $12, and installed in five minutes. The article did the convincing. The link did the converting.</p><p><strong>Why it works:</strong> You’re catching intent at its peak. Someone who just read 2,000 words on your system and thought “I want this” is the warmest buyer you’ll ever get. The link is how you meet them there instead of hoping they find your storefront later. They won’t.</p><h3>5. Run It on a Cadence</h3><p><strong>What it is:</strong> Do it again. And again. On a schedule you can actually keep, not a heroic sprint you’ll abandon.</p><p>One product is a fluke. A pipeline is a business. I listed the SDD Template one week, then shipped the second-brain toolkit the next. Two products in two weeks, both riding articles I was already writing. That’s when it stopped feeling like luck and started feeling like a motion.</p><p>I track the pipeline the same way I track blog posts, in a simple product calendar with a target buffer and a launch cadence. When a project throws off a good byproduct, it goes in the queue. The queue is what turns “I made a thing once” into “I ship a thing every couple of weeks.”</p><p><strong>Why it works:</strong> This is trait number two from Part 1, recurring need, pointed at yourself. A single product decays. A cadence compounds, because every new product cross-links the old ones, every new article resurfaces a past product, and the catalog quietly grows while you sleep. ✨</p><h3>The Real Numbers, Honestly</h3><p>I promised honesty, so here’s the unglamorous version.</p><p>Two products. Three dollars and twelve dollars. I’m months in, not years, and I’m not quitting anything.</p><p>What I can prove is simpler than a revenue figure. The loop runs end to end, twice, with no marketing budget, no audience-building phase, and no extra project work. Both products came from assets that already existed, sold through articles I was already going to publish.</p><p>Here’s the honest math on why this is worth doing even at small numbers. The article gets written whether or not a product exists, because content generation was already trait seven, already part of why you picked the project. Adding the product is a few hours of packaging on top of work that was happening anyway. The downside is a wasted afternoon. The upside is a thing that sells for years. That’s an asymmetry worth taking every single time, even when the early receipts are measured in single-digit dollars.</p><p>Passive income is a misleading phrase. The selling runs while you sleep. The shipping never does. But the shipping was already the plan.</p><h3>What Breaks (And What I’d Skip)</h3><p>A few honest caveats, in the spirit of Part 2.</p><p><strong>Don’t build the product first.</strong> If you invent a product and then go hunting for an audience, you’ve signed up for the cold-start startup grind this whole series exists to help you avoid. The byproduct has to come from real work you already did. No byproduct, no product. Go build something first.</p><p><strong>Don’t price for greed.</strong> My products are $3 and $12 on purpose. At impulse-buy pricing, a reader doesn’t have to deliberate, they just grab it. Early on, you’re buying proof that the loop converts, not maximizing a transaction. You can raise prices once the catalog and the trust are real.</p><p><strong>The free article has to actually be good.</strong> The loop dies at stage two if the article is a thinly veiled ad. Readers can smell it, and the algorithm punishes it. The article earns the sale by being worth reading even if nobody buys. If you’re not willing to give away the real thinking, this isn’t your model.</p><p><strong>Keep the day job.</strong> I know that’s not the fantasy. It’s also what makes this sustainable. The job covers your life, so the products don’t have to, which means you can price them honestly, ship on a calm cadence, and never make a desperate decision. Financial pressure is what turns a fun side portfolio into a second job you resent.</p><h3>That’s the Empire</h3><p>Three parts, one system.</p><p>You pick projects that compound, using the 7-trait filter so you’re not building in the graveyard. You run all of them with an automation stack, so the connective tissue doesn’t bury you. And you close the loop by selling the byproducts, so the work that was already generating content quietly starts generating income too.</p><p>None of it required quitting, raising money, or becoming someone you’re not. It’s the same portfolio you’d have built anyway, with a loop bolted on top that turns its exhaust into products.</p><p>The empire was never about getting rich. It’s a small, interlocking system where the same hours pay you back three ways. Skills that transfer, an audience that grows, and now a catalog that sells. Compounding, the whole way down.</p><p><strong>So here’s the last question of the series: what’s one byproduct sitting in your projects right now that a stranger would pay a few dollars to skip building themselves? That’s your first product. Name it in the comments, and I’ll help you figure out the article that sells it.</strong> 💡</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=996b039a40cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>