I Don't Think The World Needs Github.

In their article “I don’t think the world needs a new GitHub”: What GitHub’s leaders really think about their new rivals on The New Stack the author is privy to a little spat between two platforms who I just kinda hate. In the long winded treatises these guys give at their talks they go over how "agents are changing the way we build" and "we've added a gorillion gooberbytes and gublion eebeeflops to our compute infrastructure" and it's still not enough to maintain consistent 9s.

Now I know it's a bit unfair to point at the globogigacorp platform and their trillions of serves a month and say "wow seriously 98% uptime?" They are serving many orders of magnitude more individuals than I ever will, so sure. You got me. They are doing a pretty bang up job being pointless and adding to the electrical costs of Northwestern Wisconsin.

But recognize that there really isn't a fundamental need for a platform to host every single repository of code on the planet. I've made it plain that you can read my open source code at my own source forge. I don't have to serve gigglebytes of funnyflops every day because my scope is tiny and my system requirements are small. I can provide very simple read and fork optionality for users, host the systems I want to host, provide them through package providers like Packagist for versioned composer serving, and all for the miniscule cost of my own VPS.

Git is an open source algorithm that is simple to install and simple to run. Ubuntu is an open source hosting operating system that you can very quickly provision and run, even without LLMs or particular devops knowledge. There are some basic security considerations and server management tooling you may want to figure out before you do your own hosting, but why would you allow for the goobercompany9000 to serve your source code? So you can attach to their half-cocked social media system and LARP as a software dev making commits to side projects that you use to impress some HR recruiter?

Or are you interested in actually owning your work? I have projects hosted somewhere on Github. I've contributed to open source and closed source projects on Github. But there really isn't any reason for me or anyone to use these goofy, centralized platforms that can barely maintain their infrastructure under the sheer volume of slop being dumped into their ever-expanding data centers.

Hats off to the guys in the trenches solving the problems, I just think HTTP and a small server is plenty for the vast majority of projects. If the problem is discovery then github operates as a useful central platform you can mirror your code to, but I would not trust them to be your only source control.

Don't even start with me on Entire. It's all just silly.

On Personal Data Tracking

I've encountered a problem at work where I spend a large percentage of my day reviewing code. There isn't a great way to say definitively "I spend hours reviewing the team's work" because what? I'm just gonna write down that I reviewed code for 3 hours? Who's gonna buy that?

So, using Lcaude Code's new modding plugin system, I built a tool for myself. It hooks up to bitbucket, pulls the PR's branch into a worktree for us, and displays the hunks so I can review the work. Importantly, through the mod hooks, I can tie a time tracking system to the mod, so I know specifically how long I spent reviewing a PR.

It was important to me that I actually use it, so one of my requirements was that I wanted to be able to ask questions about code and get sophisticated answers against my own backlog of work, experience, and notes. So when I escape focus back from the pane into the cc session it draws the previous 15 hunks into context for the model, so we share context and I can immediately ask questions and learn what code does. It's very, very nice ux.

And it does, in fact, turn out that I spend 3 hours a day doing code review. Maybe this can make me faster, who knows, it's very fun toying with the mod ecosystem. I can do a LOT of neat things with it.

A fun detail about this is my new data capture process. I'm learning things about my workflow here, which I may want for research purposes and learning, so I store these records into a local sqlite3 database. Realizing this, I thought maybe there were other useful things to track, so now I'm doing personal timekeeping and monitoring using a haiku model to annotate my day. I can then look back on my behavior and see what I did in detail, and have sonnet write up a weekly review for myself.

Borderline dystopian if I think about it. Better yet is I can feed email, chat messages, meeting minutes and timestamps into this in order to detail out who is pinging me, why, when, and how it effects project work.

I built my own panopticon. I'm, uhh, still not totally sure what to do about it, but if the NSA is doing it to me then why shouldn't I also have these records? It is my (company's) data after all!

Anyway, point is that it was easy to do this and I have a true personal reconnaisance system for myself. Pandora opened the box, I'm just taking a peek inside, I guess.

Brief Security Outage

PHP recently had a Major Security CVE that they issued a patch for today, during which there was a brief interim where the vulnerability was unavailable for patching while the Ubuntu servers loaded the new packages. Thus, I took the site down for the moment while prepping the updates.

Thankfully it's easy enough to run commands. Unfortunately if I were not available it could represent a serious threat to my site were I not able to patch it myself. I may need to figure out a way to build some admin kill switch from my phone or something that kills fpm or something. I am not a fan of the new "we found arbitrary code execution faults in your PHP version" trends that have been occurring.

Wanna just thank the PHP team and maintainers for issuing the patch, providing appropriate notification, and a clear directive for this one. From what I understand attackers could gain fpm worker user access to the command line of the website through an OOM fault before the request ever reached application code. Literally a nightmare. Thank you to the many PHP maintainers and contributors, your work is greatly appreciated.

The Cambrian Explosion (of software)

Early in the days of Earth life was mostly single-celled according to geologists and archaeologists. However, a little over 500 million years ago the geological record explodes with multi-cellular lifeforms. The so called "fossil record" tells us that life on earth exploded at this time, and with it the exploration of new genetic combinations and environmental adaptations that brought about bipedal organisms like men (and chickens).

For reasons I won't get into here I am generally skeptical of claims dating back before ~2000-5000 years before now, so I take these stories with a bit of salt, but I won't let the analogy take over here: we are living through this very same microcosm of explosive life in terms of software!

getartcraft.com has recently cloned the adobe suite in it's entirety, in rust, open source, for free. Not only this, but the whole thing has a launcher, it's fast, and they work well! I don't own microsoft office licenses, and now I don't really need to, and once upon a time I paid adobe a few bucks for photoshop (well, my mom did haha) but man it just isn't great to be trapped into predatory subscription services unless you are an enterprise. Even then!

This is going to become fairly common, and I would argue merely cloning is going to become old hat. Far better to build native tooling for agents to do these than to simply provide a free clone of existing work. "Reverse Engineer Anything" is a powerful idea, and I'm not sure pandora will be too pleased with the contents of this box.

I wonder, too, about the money. This doesn't mean apps suddenly become free, it means the necessity of proprietary services hidden behind HTTP are going to have to become the norm. SaaS doesn't die, it becomes the only way to operate.

Needless to say Yegge was right and competent platforms are still gonna win. The best play is to get out of the way and build a road, not a gate.

What Is Verification?

Proof writing in Mathematics is the closest thing I can think of to formal verification of a claim. The logical machinery written symbolically in a series of steps to arrive at a conclusions is, to me, the purest verification of a claim.

Of course, with it comes a specialized understanding of the symbology and language of mathematics, the precursor claims the proof depends on, and the actual communication of the proof. It's a fairly complicated process, one which is tough to learn, tough to use, and tough to actually review!

However, because it's a formal procedure, we can write software that can mechanically verify a proof! This is 1) fascinating 2) unbelievably powerful.

Because software itself is a form of proof (a declaration of steps to accomplish a goal), we can build and maintain formal verification of these operations. Strictly speaking, this is what a compiler does! Clearly, a compiler doesn't go far enough in verifying behavior, because otherwise we wouldn't have UB or bugs in modern software, but it guarantees compiled code will do what it says it will do.

Beyond compilation, testing can bring us closer by isolating behaviors and guaranteeing behavior when provided with a given criteria for operation. However, this can only guarantee what you think to test! In many ways complex testing requires the full attention of the developer, and even still runs into missed behaviors!

And none of this actually tells you if what you wrote is what is actually being requested! Did you understand the requirements? Did the requester understand their own request? How do you arrive at "finished and correct" when the standards for such are often quite loose?

In my eyes this is the field we as developers need to study and apply our knowledge to. There's always been this form of "last mile" problem plaguing software projects, and it's only getting worse. Unfortunately, this is as far as I've really gotten on the problem, there is a ton of work to do towards solving this.

And I think we may be close!

On Designing Resiliant Systems

Confession: I'm a prepper. Not in the fun, wacky way where I build bunkers and stock barrels of diesel, but rather in a very practical and simple way. I prioritize savings, thrift, and productive tools. I have clean water storage, food stuffs, and plain camping gear. I camp, learn how to do simple tasks with very little, and in general prepare myself and my family for hardship.

Part of this is in simply setting aside funds for stuff. Emergency liquidity, basic tools, financial assets over transient goods. I prefer ownership over rented commodity. I read Army survival handbooks and I can draw from the appendix and dump a magazine accurately. practical preparedness is in simple tasks that stack up into a system of self reliance and resilience.

In truth, resilience is just a series of trusted components designed together with fault tolerance in mind. If one component fails, the system will tolerate the local failure and continue to operate, even if the component itself never recovers. A depleted food store can be refilled with farming/hunting skills and tools. A damaged HDD on a website's server can be replaced with a backup image of the database and a clone of the latest release image. Resilience in sum, via logical composition of parts.

I don't personally believe in resilience through theory. I prefer practical application of theory, praxis if you are a socialist I suppose haha, whereby I can verify the claims of theory in trials rather than merely assuming completeness. In applying lessons learned the old fashioned way, I can do away with the stacks of assumptions typically prevailing in most fields and build from "first principals."

And if you aren't speed running these trials with LLMs, then you are NGMI. Plain and simple. Learn, and become resilient.

Minimalism is Scaffolding For You

Refinement of process is often maturation of process. It's something I've observed frequently in the few professions I've been blessed to participate in; the best of the crew often has a very particular set of opinions and tools he uses to move the fastest and be the best. It's in the simple, refined, relaxed pose of the experienced professional that I find a few critical tools that he consistently reuses to handle the vast majority of his problems. They almost never fail him, they are always reliable, they are simply the well worn tools of the professional.

I find often the "disgust" towards maximalism to be a desire for refinement. The minimalist will pick and choose what he perceives as the maximally effective option, and ape the experience of the master by his selection of tools. This is not the same thing. The Minimalist is adhering to a program, a protocol, to project an image of professionalism. The professional simply is professional. There is overlap! But don't mistake one for the other.

Personally, I find experience and pursuit to be a higher refinement of taste than simple reference. How are you supposed to know what works if you only read blogs?

Oh, scooba does recursive donklings, clearly we should migrate our stack!

Gongkling does asymmetric compositions of non-local gloobers, let's rewrite our service with it!

I love exploring ideas and implementations, but new tools don't refine processes. Experience refines process! Knowing how something works, and how you can fundamentally implement the thing, is far and away more valuable than importing a tool.

And if you minimally implement what you perceive as "good" then you build the necessary fundamentals for critique, which is ultimately the stone upon which the professional refines his taste.

That's why I'm learning Dependable C, and why I think you should Build It Yourself.

Slight Redesign

I've actually been sitting on this one for a bit. I spent some time with codex figuring out how to do some wireframing and mocking of the website itself, which is something I've been meaning to do and haven't had the tools or time to really bother. It was fine for a process.

At work I typically do quick wireframes with Claude Design, and it integrates very nicely with the Claude Code CLI, so Codex feels just a little bit more primitive than I'm used to from Anthropic's ecosystem, but since I pay for it I may as well use it. Cliché, but I've found Codex for the purpose of organizing my own documents and processes very, very useful. And of course, Astra being a very capable vision model means I can do 3D modeling and other fascinating stuff.

I'm still building with Deepseek periodically, I have more than $10 left from my original $20 I passed in, which is more than I can say for everything else. But where Deepseek lacks is in vision and scaffolding on a harness level, which just is what it is. The Flash model has been very good for what it is in terms of cost, so appropriately mixing these models together to cost-effectively tackle projects seems like the most useful DIY path forward.

In terms of the site itself, Most of the layout changes are on my side. I updated a bunch of form layouts, cleaned up my process workflow, and decided to go a bit warmer in terms of color and design. However, I now have a true header, the footer is a bit less goofy, and navigation isn't like pulling teeth.

I have more plans for this stuff, obviously. However, this MVP project is a bit of an art project more so than it is an actual functional website. The art side of it is the hobby, the hosted projects, and the do-it-live LLM harnessing and agentic building that is so much fun to work in.

Scaling and Ceilings

Lately I've been involved in the very difficult task of figuring out what "Agentic Software Development Bottlenecks" actually means (Muh Code Review Too Slow anyone?) and have necessarily been absent from authorship while I put my whole being into moving our processes to a new age. It's probably worth briefly outlining what this actually means: The Bottleneck Of Scale!

The Bottleneck of Scale

I'm an avid Factorio fan. Diehard, actually, one of the greatest games of all time. What you realize while playing is that "scale" is really just a fancy term for process. You can mine all of your iron with burner miners, but you don't want to because that's boring! So you enhance your production lines with scalable tooling and infrastructure, you learn patterns of building that leads you towards reusable systems, and you design factories that get out of your way. It's Very Fun, and it's what I've found my profession to ultimately be: scaling systems so the systems get out of our way.

What's become apparent in recent months is that our software output has been stoppered by our verification process. We only have a few people who's responsibilities vary and who's priorities are unstable, so verifying the "Quality" of a given project can take a good while. The problem we had was that our deployment process has a few different environments we deploy into, and originally we used isolated branches for this. Huge problem with that is once your code velocity increases, suddenly even unrelated changes collide with each other on non-main branches, causing deployment "brown-outs" (endless merge conflicts). So I spent a few weeks and many hours building out our team's feature branch system and deciding on a more-robust CI/CD strategy for agentic deployment (push straight to main haha).

I joke a bit but I truly think "straight to main" is correct these days. Time to Deployment being hours as opposed to days means agents aren't colliding on shared utilities, problems are solved immediately, and long-lived feature branches don't require hours of a senior developer's life to parse the git merge conflicts. This is how I do stuff at home because my scale is small, but at work? How can I be confident "straight to main" is correct?

You see, that's the time sink. I spent weeks combing our new test suites, correcting issues, designing merge queues and pipeline yamls to make sure our pipelines are fast, cost-efficient, and correct! It was particularly important I did this now as opposed to later because we are currently in a very opportune moment at MenuMetric to restructure our deployment infrastructure for reasons I'm not at liberty to declare here. However, It's given me great insight into the future, and in particular scaling our infrastructure in such a way that it gets out of our way so we can solve problems faster, more correctly, with fewer hours spent hemming and hawing over if it actually works, because we now have a deployment procedure that guarantees past performance for the current deployment.

I'm a few days away from declaring myself the Devops Tzar of MenuMetric, another one of my many titles I have taken up. Anyways Laravel's Pennant is pretty slick and Merge Queues are awesome, I think I'm going to be taking a lot of these lessons from work and applying them to this site, which has been dormant for a while. Lot's of stuff to do, I need to make some GPU Steam soon.

Slice of Life

I've finally got a site redesign prepped for here, and I've also been on the Dependable C bandwagon lately, so expect to see some C projects. At some point I swear I promised a native reader for this website specifically. I have been building my own ncurses library from scratch; TUIs have always fascinated me, so that's what I've been up to lately.

OpenSCAD and Codex

I'm an aspiring woodworker, but I lack a proper bench in my garage. While what I have is a "bench" it is neither level nor stable, and was clearly designed by somebody winging it. However, as a novice, I have no idea how to build a bench! So, clearly, in the spirit of DIY and learning new things, I took it upon myself to work with my ChatGPT Plus subscription to figure out how to do some CAD modeling without needing to frontload an entire undergraduate's degree to learn how to do the drafting!

Some very neat things I have discovered in the process:

1. Open AI's Codex App is very straightforwardly good for this kind of exploration
2. Astra is very good at doing OpenSCAD model design for somewhat simple structures
3. If you run into issues with WSL2 Interoperability between Windows and WSL2, you can just redownload OpenSCAD in WSL2

Now, this isn't just to play with OpenSCAD (although, it kind of was haha!) because doing any sort of wood working at a scale like this comes with quite a bit of money to spend on material. Even being thrifty, cutting down on the components of the bench, and designing around modularity, I'm still looking at ~$500 for the whole construction to be useful. While I'm not poor per se, I'm a skinflint and wasting any amount of that $500 budget is not acceptable. That's why this has been unbelievable; I can run some simple dimensions and pictures at Astra, describe what is there and what I need, work out some designs in OpenSCAD, and suddenly I have

1. A budget
2. A cut list
3. An Exploded view with construction steps built into the assembly
4. A session context I can retain for the future when I inevitably run into problems

I can accomplish in a single afternoon a far more complex and comprehensive planning session for my next few months of woodshop time and budget than I would ever have been able to have doing it by hand. Could I have drafted the design on paper? Yes. Could I have guessed at the material cost? Yes. Do I have the time to do all of this within a single afternoon? No. Frankly, I'm far more interested in cutting wood and learning the craft than I am in learning how to draft three dimensional models, even though both are skills worth learning! Someday I'll be able to come back to OpenSCAD and do my own drafting via code, but Chat GPT can't operate hand tools and I can't type as fast, so we may as well prioritize with one another!

As a matter of fact, I do. However, this is a custom job GPT did for me, and you could just do it yourself. However, in the interest of retaining potential monetization options I'm going to withhold some of these from open source for the time being. In the future I might just upload the OpenSCAD files to my source forge, but benches are special and well designed plans with a well-bundled instruction pamphlet might be worth good money, so I'm going to sit on the models for a while before open sourcing them. I gotta build the bench first, anyway! It cost me a few pennies for my 5hr session today to get a sophisticated model and project plan, so if you really need something I suggest spinning some drafts up yourself in the meantime.

SOTA

Here's a question worth asking: why don't we use screws for framing? When building a structure, doesn't it make sense to use a fastener designed to wrap the wood fibers for a tighter fasten between two planks? Why do we use nails instead, which don't have the same capacity to fasten two planks together?

If you spend any amount of time thinking about it, you realize that the fastener's job in a framer's process is only one variable. The pace with which he can fasten two boards together matters far more than the quality of the fastener, because the framer has hundreds of boards to fasten for any given structure! The speed with which he can slam a nail home is faster by an order of magnitude than how he can set a screw with a drill.

So this begs the question: are you using screws when you should be using nails? Fable 5.1 costs dollars to operate, but the vast majority of problems worth solving are not fable-level problems! I'll be perfectly honest, the step up from fable 5 to fable 5.1 or from sol to astra has no bearing on my capabilities in 95% of the problems I have to solve.

We are at a point where most of my problems can be carefully orchestrated with cheaper models and better harness strategies. Maybe the problem of orchestration and governance can be offloaded to fable-level intelligence, but then we are back to the same problem of governing the governor, and at what point are we satisfied with the quality of output mediated by an LLM? To what degree do we trust Astra level automations to do what could otherwise have been performed by more sophisticated deployment gates?

And if we know Astra has shown itself capable of sandbagging, and of hiding it's Chain of Thought, why then do we continue racing to the bottom where most of us can no longer afford to participate?

In any case, choose your fastener wisely. Not every project is solvable through wood frames and nails. Not every framer should be working on your project. Not every contractor is worth his rate.

Contradiction: I Like Code Review More Now

I spend a lot of time doing CR these days. At the moment it's one of those verification gates we have that's load bearing, and even with some automated testing and CR Invariant linting we are still doing a ton of Code Reading lately. However! I think this is actually probably the most fun time to do code review!

I Can Talk To Robots

Previously CR always felt kind of like "am I wasting somebody's time asking stupid questions in a PR?" But I've actually found that often it's stupid questions and "wait, really?" style review that can at once feel kind of personally insulting and also heavily rewarding if you can hit CR with an egoless process (hard). Often it's pointing out the blindingly obvious where CR's highest alpha is, and, well:

1. Nobody wants to be the "well duh" guy
2. Nobody wants to be the "umm... really?" guy

But now I can just ask robots braindead galaxy-brain style questions like "why is this inline style like this and not a custom component?" and software like Code Rabbit (not sponsored but we use them at work, it's great) will respond to my question immediately and with interesting feedback. The pace of agentic development also means we can very quickly pivot code comments into actionable changes that make a PR tight and well-built, with new optional directions to address tech debt, to resolve tech debt quickly, and to provide new work to address budding tech debt. It's actually really interesting and worth our time as an engineering department to ask dumb questions now, because we get all sorts of new ideas and perspective on how to build things better, mostly because there literally are no dumb questions anymore. Only dumb answers.

It does require a careful eye to catch dumb answers, though. That's worth a second thought.

Miniroute!

Wow What a Ride! This has been a project man, I never expected open sourcing a project to require so much effort! Just getting something extracted and managed into a usable utility anybody else could pull/clone/read requires so much more work than I thought. Source Code and README.md for any interested reader. It's kind of magical that this can actually be used by anyone who includes it via composer, even though realistically this is going to be mostly a single-user piece of source code. However, screw frameworks! Everything should be a Kernel!

The thorough reader may notice the themes of the package:

• Single Dependency of PHP Unit by the great Sebastian Bergmann
• Lightly Opinionated on user definitions and operational patterns
• Simple and direct usage patterns

Granted, the package requires a decent amount of reflection usage to function, there are a number of known issues as of writing, and the resolver pattern isn't terribly intuitive for anybody unfamiliar with how the package works or how PHP works. But! That all said this little v0.1.0 release party has required a substantial amount of work outside of the package itself, including setting up my hosted environment with cgit, managing push/pull permissions over my tailscale authentication layer, maintaining my own source code on the site and managing the project itself alongside the actual work I have to do on this site. Man! It's been a ride!

Anyway in case you were wondering what my psychosis level is the first person I shared this project with was GPT 5.6 Sol who was a core component of helping me realize I could do this kind of thing. If you were curious, no this was not entirely vibe coded, the skeleton was hand designed in temp files within the site itself as an exercise, where I then realized it was super cool and wanted to publish it as a standalone package.

Well That's Just Plain Silly

So FreeToken makes local-first options look insane now. not only am I seeing deepseek flash being run on two 3090s local, but also GPUs like the 3080 no longer appear to be priced appropriately!

Imagine: a 3080 running MoE models hosted mostly in RAM, you can and would be able to carry long-context operations with speculative decoding at rather-high TPS simply by allowing the used expert to reside on VRAM. Whole worlds of Local Language Models open up at silly prices because we are no longer tethered to jamming compressed models directly onto the GPU.

I, for one, am looking at the used market a bit more closely now and am reconsidering what self hosting has to look like. And, if large enterprise ram busses are on the table, there is a possibility we could be looking at higher TPS for multi-agent long-context boxes running with compartively-tiny VRAM counts for what was only a week ago looking more and more bleak in terms of self hosting.

Watershed moment, at least until the 3080s get bought up, my link leads to an empty seller page, and we are back where we used to be in a GPU drought. Hey, at least it's something. Maybe RAM prices will go down if VRAM stops hogging all of the manufacturing attention!

I won't hold my breath!

Cheap Models

So I've been doing some personal investigation and analyzing the cost-to-compute for various models, and what I've learned is that traditional ops for my site here are probably stupid and expensive for the kind of operations I need. This site isn't complex per-se but running everything from scratch on a small VPS requires me to be a bit more economical and discerning when it comes to technical dependencies, so I've been reviewing my own usage with Deepseek v4 flash and comparing in-house options. It's difficult to beat chinesium subsidy, but also selling my internal details to a third party is

1. not the point of my site
2. a liability
3. did I mention branding?

So I'm left considering options, and the in-house options do not look great. I currently have a 6 year old 2070 Super which still kicks butt, but with only 8gb of VRAM I'm kind of stuck running micro-models like Gemma e2b on the card, which also takes away my ability to use it for other, video-game-related activities. So, purchasing options include:

• Machines I cannot afford like the 5090.
• Machines I can no longer find on the used market like the 3090.
• Machines that generally lack effective vLLM support or Cuda magic like the Arc B70 Pro.
• Machines that are purpose-built with VRAM bandwidth in mind like the Thinkstation PGX Spark, and which are completely out of my price bracket.

I'm also just a cheapskate, so spending a lot of money on something like this irks me. I'd prefer to use what I have or be thrifty, so obviously my ideal has to be some secret alternative option that nobody has found yet! Well, almost nobody, some folks are totally hogging DDR4 ram sticks for this, but you can technically run LLMs slowly through the CPU so long as you have a decent RAM bus that can transmit RAM into the CPU, which is what most enterprise-grade servers are built for. And guess what you can buy for rather cheap on second hand markets!

If you think about where LLM utility comes from, most of the value comes from long-running tasks that can utilize multimodal intelligence to perform work through tool calls and agent harnesses. While having ~60-80 tokens per second is nice for chat GPT, it's rather pointless if the model is spending most of it's time gathering context through tool calls and selecting best-fit against MTP predicted tokens for software outputs. Having high-speed, long-context, cheap agents is a nice dream, but you get to pick 2 these days, so why not opt for bulk and parallel operations over raw speed?

Imagine for a moment: A used Epyc series chip running on a mobo with well over 200gb/s over the bus, with access to well over 256gb glorious DDR4 RAM. You could very easily stand up 4 Qwen 3.8 27b coder models that run in parallel with MTP at very-long contexts (YaRN-compatible I hear), depending on the chip series and ram it's not unbelievable to assume you could hit ~7-10 tps, and if you just design your work items ahead of time it can chug in the background against your verification CI/CD and review steps autonomously, chewing through your deliverables and bringing your given projects to life, all for the low, low cost of ~$1500 worth of used, enterprise-grade components.

It's absurd but guys seriously I can't find a 3090 for less than $1,500 this is a plea for help.

Things Break!

"It should just work" is a lovely little idea held by the deranged. After a few years cutting your teeth on any project you realize

1. nothing ever just works
2. and why should it?

Just experienced one of those lovely little issues where a "change that shouldn't effect anything" (preparing a separate subdomain for a distinct nginx server) caused a complete outage of the main site! Haha! Classic! And of course I, a fool, haven't set up any automated health checks so the failing https certificate was just hanging out for a few hours while I watched a movie with my wife. Ah well, nobody reads this stuff anyway except for the scrapers (I <3 seo).

Anyway, a confusing 20 minutes later I also had a great realization that the reason people pay supernerds to do this kind of stuff or just offshore to a SaaS company is that these web servers are finicky little trinkets that prefer to not be touched very often. The moment you start screwing around with doing stuff yourself you open yourself up to all sorts of things you wouldn't ever know (changing a wild-card port address match to be a strict IP address causes nginx to fail to route other wild-card addresses, like my primary site's landing page).

Some of you are calling me a Rookie, and yes, I am. None of this was possible for me to do in the few hours of spare time I have a week to tinker before deepseek. I can now slow roll my own deployment infrastructure and remote publishing site for my own software. "Just don't do it if you don't know what you are doing, RTFM" shut up, nerd, don't you have some PHP RFC to reject?

Move Fast; Break Stuff! It's ok, you can fix it.

Code Review is an Anti-Pattern

I'm not the only one to have had this controversial thought. It seems to rub some folks the wrong way, but code review in general is a huge waste of time. On any given team there are approximately 5% of the team ornery enough to care about "code quality" to endeavor on the task of telling other people to change how their code is written. And, because it's only ever a small cohort, the whole job inevitably falls on them to perform the code review! This type of pareto distribution isn't new (80-20 in terms of work completion is a common complaint) but specifically if the intention of code review is to improve "code quality" then the vast majority of the time it is not doing that.

I prefer effective review stages. I want good review! If my software is going to meaningfully exist alongside other people's software we have to somehow reconcile our different versions of the build together. But just stating "have better taste" doesn't mean anything when the 5% of the team is now left reviewing an order of magnitude more PRs from junior developers, some of whom might not even really know how to actually code by hand anymore. "Reconciling code" cannot functionally remain a manual process, in the same way that most teams these days are not functionally capable of manual release cycles due to volume. CI/CD isn't really optional after a certain scale, and that scale margin (headcount of developers within a department) has been reduced significantly.

And while there are tools out there that can perform non-static code analysis, they still require the time and attention of development teams to write down the standards and expectations of their code and to provide those standards/expectations to the tools performing the analysis. And with agentic analysis you still lose the benefits of discussing code patterns with junior developers and building relationships with one another while building inside a shared environment. If the purpose of code review is to provide guidance/counsel to juniors while also maintaining useful coding standards then

1. code review isn't currently doing that well
2. software engineers have been coping about code review for years
3. we finally have an opportunity to build software communication platforms that will functionally work in favor of the requirements, not just pretend to

I desire practical review stages, and I think agent harnesses underlie the functional review stage. I think instead of reading code we should be discussing the purposes and design patterns in context of the business requirements, and encoding that knowledge into a shared, discoverable repository where new code can immediately draw from rather than require blind discovery from accidentally stepping on some senior engineer's toes. I think the zed team are on to something (I routinely use their IDE, I'm a shill frankly), but also I'm not certain we've really explored the space in meaningful depth yet. Basing our assumptions off of code review itself has driven the conversation in a direction that somebody who knows better would have immediately noted as an anti-pattern. "I know this looks fine and almost clever now, but once you scale this pattern it's going to require an enormous amount of effort to detangle it."

Steve Yegge actually discusses some of these alternatives in depth, so I won't really go too far further. It just felt important now as I'm actively configuring my remote CI/CD review and deployment strategies for this web page and my project repository. I don't "review" the code in detail but I still read and write within it to keep up with the patterns and scalability needs as the agents delegate work and prioritize.

AI NaTiVe

The Jeddah Building in Saudi Arabia is slated for completion in 2028 and in light of this I think it is worth considering briefly the hype surrounding some of the most influential technology in the world: Google's Transformer. We live in a world where computers can process arbitrary text and generate inferential text from the contextual text, performing a "next-token prediction." The systems and engineering that now surround these systems are surprisingly sophisticated, in thanks to the ability for engineers to literally dump context into a system that can render said context into more context.

Nativity to Large Language Models is another one of those interesting acceleration curves. You've either been inundated with these things or you've been blissfully unaware, and there are very few folks genuinely in between. In some circles this is the "exponential curves look the same no matter where you are on it," we all feel left behind but in real terms some folks are just simply, truly left behind. This would be the "native" delineation.

Being "left behind" means you have failed to follow the "trends" in a literal sense. You are "exponentially left behind" meaning every moment you try to catch up you are always lagging further behind! Maybe you can "catch up," there isn't any rule saying you can't accelerate faster using these systems to build your understanding more efficiently than the leaders on the frontier, but even still you are fighting adoption headwinds, rate of change isolation, and a steepening learning curve every day; singularity.

The question these days is not whether these things are useful (they are by all meaningful metrics, don't be daft) but whether they will be economical. Credit is still cheap, the Saudis are standing up their next Biggest Thing Ever Because They Can, and every single SV Giant is making a mad dash for ever-larger facilities to pass electrons through blocks of VRAM. The good times seem like they will never end, we only ever go up.

Well, until folks start defaulting on their mortgages, anyway. Eyes up, keep a little liquid, and don't forget how to code.

Regarding Agent Memory

Karpathy's Gist is one of those "duh" moments from the last few months everybody sort of collectively realized was reasonable ~2 months after he published it. I think once we all realized "embeddings" were just a mechanical way to match sentiment against batches of text, the magic went away and RAG was revealed to be a big waste of resources.

Some folks will say "uh, yeah, we all knew that big dawg" and the same ones have been vibing out for months accomplishing mostly the manufacture of ever increasing tool kits for their agent swarms. As far as actual utility is concerned, Karpathy's approach (just feed the model the raw data in it's entirety) is becoming the standard.

With the rise of firms like Subquadratic (SubQ?) Where massive (alleged 12 million token) contexts can be fed directly into prefill, it's hard to deny the movement of the tides. But, I'm stubborn.

There are just better ways to gain quality output with quality input orchestrated by a model, for cheap. Beads does almost all of the heavy lifting something like Jira or Obsidian would give me for ~0 effort. Holding the changelog context directly next to git just... makes sense to me. Like tying a branch to a jira card, you get change context, diffs, reasoning, and project scope tethers all right in line for agents to grep against.

There are very good reasons to not reinvent the wheel, but I think gastown did make one of the most useful context management systems available. Use it!

The Backlog

So I'm a hobbyist writer, I do this stuff for fun, but I'm a software engineer by trade so building the architecture around the hobby of writing is my ultimate outlet. So of course both endeavors come with a significant and growing backlog of ideas and concepts I'm working on.

Authorship

I'm always turning over ideas in my head, playing with works I want to compose, so naturally I've got about 3-5 blogs on the shelf I'm sitting on to a single actual published blog! They are technical and philosophical pieces relating to this site and my software idealism, which I hope to draw out conceptually through these notes and a growing link-graph of concepts.

Engineering

I've posted here and there some of my thoughts and progress, but these are small improvements towards my ideal. My list of items to update has doubled over the last week, and I've hardly made a dent! Even with AI my concept board is quickly outpacing my ability to finish these projects.

Even still, I have plans on hosting my own MIT projects here within the year, self hosted git and everything, as well as downloadable binaries with checksums. I want to build my own compiled php redis implementation, and I have a deepseek harness with some personal ideas on token usage and orchestration, amongst other miscellaneous ideas I've had. None of these projects are anywhere near complete (let alone started) and the site is still technically not feature complete for my ideal composition. That's what an MVP is for I guess.

RSS/Atom feed are on the docket, as well as some neato graph stuff for linkout displays. Have some data design updates though to make those better. Anyway, back to 'er!