đ Escalating retail wealth with automated software
âł Life is too short to be stuck in a 9-5 grind
đž Putting your money on autopilot
đŹ DM's Open
got written up at work for being on my phone during calls
phone was executing trades while i was talking to customers
$31K a year call center job. manager had me on a performance plan
quit the following friday
here's what i was actually doing:
courtlistener publishes every federal court docket update, completely free
when a hearing gets added on crypto enforcement, drug pricing, FDA approvals - Polymarket questions on those topics haven't repriced yet
45 to 90 minute lag. just needed to be faster than the crowd
Claude reads the feed every 8 minutes, matches new hearings to open Polymarket questions, scores by KL-divergence
if number clears 0.11 - bot enters
3 months:
> 2,104 trades
> 71.8% win rate
> +$38,240
best single trade: SEC enforcement hearing added for a crypto exchange. market priced 31%, model said 74%
entered at 0.31, resolved at $1.00 - +$970 from one docket update
my manager spent 20 minutes on a counseling form about my phone
made $174 in that window. never went back
courtlistener has been public since 2003
nobody thought to cross-reference it with Polymarket until i ran out of excuses to stay
Coding Was Never the Hard Part | Koushik Dasika, Hacker News
What I Wish Every Business Leader Knew About AI and LLMs
Thereâs a lot of excitement right now about AI making software development faster. Agentic coding is real, Claude Code, OpenAI Codex, and Gemini are real, and so are the open source alternatives running locally via Ollama: DeepSeek, Qwen, Gemma, Llama, and more. The productivity gains are real [1]. The marketing around these tools promises that they solve everything. And in the background, AI is getting blamed â or credited, depending on who you ask â for a wave of engineering layoffs. But most of the conversation is happening inside a very narrow frame, one that makes total sense if youâve never worked in engineering, and makes almost no sense if you have. This post is my attempt to bridge that gap. Not to push back on AI, not to gatekeep engineering, but to give business leaders a clearer picture of how engineering actually works so we can all get more out of it together.
Let me get something out of the way upfront. I am not an AI skeptic. I use AI every single day across everything I do. It makes me a better engineer than I ever was. This is not a doomer post. This is about nuance, specifically the gap in understanding between business and engineering that AI has made way more visible. If youâve ever looked at your engineering team and wondered why tickets take so long, this oneâs for you.
Most Work Is Task-Based. Engineering Isnât
Think about how most departments operate. Sales has a pipeline. Operations has checklists. Even with AI tools like Claude Cowork, the unit of work is a task. You do it, you check it off, you move on. Faster execution almost always means better outcomes. The variance is small.
Engineering is fundamentally different. Engineering follows the scientific method.
The coding part? Thatâs step E. For a senior engineer, thatâs roughly 20% of the actual work. The other 80% is research, planning, designing the right solution, and then collecting and interpreting results. This is why âplan modeâ in tools like Claude Code, Codex, and Gemini resonates so much with engineers. It mirrors how we actually think. And itâs no coincidence that most best practices posts are really just about improving the feedback loop at the end.
And thatâs only talking about feature development. It doesnât account for everything else on an engineerâs plate: code reviews, meetings, fire drills, on-call rotations, admin work, mentoring, documentation, and just keeping the existing system alive. Software has entropy. Left alone, it actively tends toward failure â dependencies go unmaintained, infrastructure drifts, things quietly rot. Sweeping the floors is a very real part of the job. Nobody is shipping features the whole time. The 20% figure is already generous.
Hereâs the math that should stop you mid-sentence at your next planning meeting.
If coding is 20% of an engineerâs job, a 50% speedup in coding yields only about a 7% total productivity gain.
This isnât just intuition â itâs known as Amdahlâs Law. The formula: S = 1 / ((1 â p) + p/s), where p is the fraction of work being sped up and s is the speedup factor. Plug in coding as 20% of the job (p = 0.20) and a 50% speedup (s = 1.5):
S = 1 / (0.80 + 0.20/1.5) = 1 / 0.933 â 1.07
This law states that the speedup you get from optimizing one part of a system is limited by how much of the total work that part actually represents. If the sequential bottleneck is small, no amount of parallelization, or AI acceleration, changes the overall outcome much. AI can help with the other phases too, but most people arenât even framing it that way yet.
What AI Is Actually Great For
Thereâs no shortage of articles about what AI does well so I wonât rehash all of it. Hereâs where I actually find it valuable day to day:
- Rubber duck and scribe. Thinking out loud with AI to process problems is underrated. Itâs like having a very patient, very knowledgeable colleague available at 2am.
- Kills activation energy. Starting is the hardest part of most tasks. AI lowers that bar considerably.
- Documentation and tests. The stuff engineers know they should write but hate writing. AI is great at this.
- Greenfield scaffolding. Getting a project off the ground quickly. AI shines here.
- Writerâs block. Specs, RFCs, PRs, emails. AI handles the blank page problem well.
- Raises the floor on your weaknesses. Where youâre strong, its shortcomings are easy to see. Where youâre weak, it trivially lifts you to at least median level. This is actually whatâs driving most of the excitement around AI â and itâs something engineers and experts need to lean into. Work has many dimensions. Focus on your strengths, let AI shore up the rest, and youâre operating at a higher level overall. (This post exists because I canât write. I had opinions. Claude had sentences.)
AI is useful at every stage of the scientific method. The key word is useful, not autonomous. That distinction matters a lot.
AI Makes the Most Common Decision, Not Necessarily the Best One
These agentic coding tools (Claude Code, Codex, Gemini, and open source models like DeepSeek, Qwen, Gemma, and Llama) are impressive. For a brand new app with no prior context, they move fast. But hereâs what theyâre all doing: making the most statistically common decision for your situation, not the best one for your situation. They donât have your context. And your context is everything.
Thereâs a pattern worth naming in conversations about AI. The people most confident that AI can just replace engineers tend to be the ones who use it the least in a real engineering context. The more you actually work with it day to day, the more you see its edges. Itâs not a knock on AI. Itâs just how expertise works.
Here are real variables that shape engineering decisions that no LLM will ever know on its own:
- You went to a conference and talked to a library maintainer who is shipping something in 6 weeks that makes your whole problem easier
- A dependency you rely on just went unmaintained
- A cloud provider or SaaS changed its pricing model after the modelâs training cutoff
- Your team is strong at X and weak at Y, so you weight solutions differently
- The âcorrectâ solution would take 3 months. You need to ship in 3 weeks. So you pick the approach thatâs 80% right but lets you pivot cleanly later
None of that is in the model. A senior engineer holds all of that in their head and navigates it constantly. Thatâs not coding. Thatâs judgment.
No two projects are alike because the context is always different. But projects rhyme. Thatâs the trap â the surface looks familiar, so shortcuts feel safe, until the context underneath diverges and the decision falls apart.
This is also why, regardless of who or what wrote the code, production PRs deserve the same review process. If an agentic tool wrote a feature, it should go through the same scrutiny as if a junior engineer wrote it, because while the model may have many of the same blind spots as a junior engineer, it also has technically unique blind spots as well: no organizational context, no awareness of the edge cases your team has learned the hard way, no understanding of the SLA implications of that one innocent-looking change. The code might look clean. That doesnât mean itâs right for your system.
The Variance Problem (And Why the 10x Engineer Is Real)
For task-based roles, the variance in outcomes is fairly small. A good salesperson might close 2x more than an average one. For engineering, the variance is enormous. There are infinite ways to solve any problem, and youâre relying on your engineers to navigate a multidimensional tradeoff space that reflects your companyâs values, constraints, and goals. No two engineers have the same skills â the dimensions are too many: frontend, backend, databases, eye for design, people skills, domain knowledge, system intuition. Every engineer is a unique combination of all of these.
This is why the term â10x engineerâ exists. Itâs not mythological. Priceâs Law puts a number on it: roughly half of all output in a given field comes from the square root of the total contributors â originally observed in scientific publishing, but the pattern holds across knowledge work. On a team of 25 engineers, about 5 of them are doing half the meaningful work. The difference between a great engineer and a mediocre one is genuinely that large on complex problems.
And it cuts the other way too. There are engineers out there where the best possible outcome for your business is that they do nothing. Negative impact is real. The -10x engineer is just as real as the 10x engineer. The floor and ceiling are both extreme. When business instinct says âjust hire more engineers to go faster,â thatâs fighting against Brooksâs Law: adding people to a late software project makes it later. The ramp-up cost, the communication overhead, the context transfer. It all slows the team down before it speeds it up, if it ever does. Engineers are expensive and hard to find, which makes the variance problem even more consequential. Youâre not hiring a commodity. Youâre hiring judgment.
The Tacit Knowledge Problem
When business people or agentic coders peer into an engineering codebase or process, they often hit a wall. Things that seem arbitrary. Decisions that arenât documented anywhere. Patterns that feel inconsistent. This is tacit knowledge: shared context that engineers carry culturally that never gets written down.
Why doesnât it get written down? Two reasons:
- Documentation ages. Without constant maintenance, it drifts from reality fast. Outdated docs are often worse than no docs.
- Maintaining docs is a full-time job. One that generates zero revenue. Itâs hard to justify when thereâs a roadmap to ship.
âJust have AI write itâ is a reasonable reaction, but AI context windows are precious. Research has shown that early context disproportionately influences the outcome of a session [2]. Flooding it with documentation has real tradeoffs. This is still an evolving area but itâs not a solved problem. The tacit knowledge gap is one of the biggest reasons engineering looks opaque from the outside. Itâs not gatekeeping. Itâs just how knowledge-dense work accumulates over time.
Moving Fast Has a Hidden Balance Sheet
âProducing the wrong thing fastâ makes sense as a strategy. More attempts at product market fit means better odds of finding it. The logic is sound. What business doesnât see is the engineering balance sheet on the other side.
Every attempt leaves behind maintenance cost and operations cost. Every feature built on a rushed foundation makes the next change more expensive. The cost of change compounds over time. Every engineering discipline youâve ever heard of (design patterns, frameworks, modularity, separation of concerns, abstraction) exists for exactly one reason: to slow the growth of complexity. Not eliminate it. Slow it. This is Gallâs Law in practice: complex systems that work always evolved from simpler systems that worked first. Skip the simple working foundation and youâre building on sand.
Even with great engineers doing everything right, complexity grows. The goal is to keep it logarithmic. Under deadline pressure, that growth rate goes up. Corners get cut, the foundation gets shakier with every sprint. At some point you hit a wall. Changes that used to take a week take a month. The codebase becomes so entangled that pivoting is nearly impossible. And if the market shifts at that moment, the business canât respond fast enough. The company can die from its own technical debt.
This isnât theoretical. Iâve been laid off twice from startups where exactly this happened. The market shifted, engineering couldnât pivot fast enough, because of decisions made years earlier under pressure to move fast. Complexity is a fact of life in engineering unless youâre truly throwing everything away and starting fresh. The only question is how fast it grows.
Complexity Is a Sign of Success. Itâs Also a Trap
Every long-lived, successful codebase becomes extremely complicated, not because engineers were sloppy, but because the reality it models is complicated. Software that survives long enough is just a mirror of the real world. And the real world is messy.
Hyrumâs Law explains part of why this is so hard to change. With enough users, every observable behavior of your system, including the bugs, the quirks, the undocumented side effects, becomes something someone depends on. You canât just fix it. You have to manage it. This is why mature systems are so hard to refactor even when everyone agrees they should be.
This connects directly to the Innovatorâs Dilemma. Pivoting fast is easy when you have nothing to lose. The more successful you become, the harder it gets:
- Existing users who depend on current behavior
- SLAs youâre contractually obligated to hit
- Integrations that break if you touch the wrong thing
- Years of business logic baked into the codebase
This is why scrappy startups can outmaneuver established players with a fraction of the resources. Itâs not that big companies are lazy or bureaucratic. Their engineering surface area is enormous and every change has blast radius. The cruel irony is that success makes you slower. Businesses that donât understand this get frustrated at exactly the wrong moment and push for pivots that engineering physically cannot deliver cleanly. Not because engineers are dragging their feet, but because the weight of all that prior success is sitting on top of every decision. Complexity isnât a failure. Itâs a consequence of survival.
What Business Should Actually Push For
The breathless AI posts are all about coding speed, and that makes sense. Coding is the hardest part for non-technical people. Itâs the most visible blocker when you donât have a technical background. But for engineers, coding is not the hard part. It never was. The hard parts are everything around it.
You think coding is the bottleneck because coding is your bottleneck. It isnât Engineeringâs.
This is also where Goodhartâs Law bites hard. When velocity or ticket throughput becomes the target, it stops being a good measure of actual progress. Teams optimize for the number, not the outcome. You get faster delivery of the wrong things, or shallower solutions to the right things. If you want to measure something meaningful, measure the quality of decisions made in the research phase and the signal coming back from the results phase. Thatâs where the real work happens.
Protect the research phase. Rushing engineers to âjust start codingâ often produces the wrong thing fast. And as we just covered, the wrong thing fast has compounding costs you wonât feel until itâs too late. Remember Hofstadterâs Law: it always takes longer than you expect, even when you account for that fact. The research phase wonât eliminate that gap â nothing does â but skipping it guarantees you start with less information than you need. Cutting it doesnât save time. It defers the cost.
Invest in the feedback loop. Observability, metrics, user research. The results collection phase is where you find out if you built the right thing at all. Most teams underinvest here badly.
Optimize for the medium term. The instinct to push for faster execution makes sense in the short term, but planning â timeboxed and kept within reason â rarely causes problems and prevents them far more often than not. There is a reason the military saying slow is smooth, smooth is fast has survived as long as it has. Taking the time to move deliberately through the research and planning phases is not lost time. It is the thing that makes execution fast when it counts.
The Call to Action: Collaborate in the Process. Have the Conversations
The whole thesis of this post is that engineering follows the scientific method. Research, hypothesis, execution, results. Thatâs the loop. And the single most important thing business can do is understand that loop and engage with it, especially at the beginning.
Hereâs why the beginning matters so much. Scope reduction has the highest leverage in the research phase. If business and engineering sit down together before a single line of code is written, a 10-minute conversation about priorities can eliminate weeks of work. âWe donât actually need this for v1â is worth infinitely more before the architecture is designed than after. Once youâre in execution, changing scope means undoing decisions, rewriting code, and managing the complexity debt thatâs already accumulated. The earlier the conversation, the cheaper the tradeoff.
Conwayâs Law tells us that organizations build systems that mirror their communication structure. If business and engineering are siloed, the product will reflect that silo: disconnected pieces that donât quite fit together, built by teams optimizing for their own side of the wall. The fix isnât a process change. Itâs a conversation change.
The other place collaboration matters is at the results phase. Engineering needs to know if what shipped actually worked. Did users adopt it? Did it hit the business outcome it was supposed to hit? Without that signal, the next research phase starts blind. Business holds a lot of that signal and often doesnât realize engineering needs it to close the loop. Sharing outcomes isnât just a nice-to-have. Itâs what makes the scientific method actually function as a cycle instead of a one-way waterfall.
So the ask is concrete: get in the room during research, align on outcomes before execution starts, and close the loop after results come in. I know everyone is slammed. But the ask is small relative to the cost of not doing it. The cost of that conversation is an hour. The cost of not having it could be months of building the wrong thing, compounding into technical debt that eventually boxes the business in entirely.
This is also where a lot of the engineer pushback on AI mandates is coming from. AI can be enforced top-down as an initiative, but it is never accountable for the outcomes. It isnât on call when something breaks. It isnât carrying the weight of every feature added to a codebase that compounds in complexity over time. Engineering is. It is also worth noting that AI companies have a direct financial interest in being deployed against large, complex codebases â that is a lot of tokens. The incentives are not perfectly aligned with yours.
The layoffs are part of this picture too. Big tech has been cutting engineering headcount at scale, and AI has been cited as both the justification and the path forward. That is the context engineers are operating in when they are asked to adopt these tools. When something built with AI goes wrong, the tool doesnât take the blame. The engineer does.
That frustration is not resistance to change. It is a reasonable response to a real asymmetry. The ask is simply to be honest about it. Treat AI like the tool that it is, deploy it where it genuinely helps, and donât paper over the tradeoffs. Thatâs the only way the collaboration actually works.
Where This Leaves Us
Agentic coding is here to stay. AI is here to stay. I use both constantly and Iâm not arguing against either. Iâm arguing for shared understanding.
Engineers arenât slow. Theyâre navigating tradeoffs you canât see, with context that isnât written down, in a problem space with enormous variance in outcomes. Every decision they make is either slowing or accelerating a complexity clock that will eventually come due. AI makes all of us better at this, but it doesnât replace the judgment. Not yet.
The most valuable thing a business leader can do right now isnât push for faster coding. Itâs create the space for engineering to think, plan, and collaborate. Thatâs where the real leverage is. And it starts with a conversation.
Read more:
https://t.co/hA1240r0em