For the first time a solo developer does not need a big team, a custom platform group, or months of internal tooling work to build a serious software delivery system.

You can bootstrap your own self hosted platform now.

Not because infrastructure suddenly got simple, and not because AI magically removes engineering discipline, but because modern coding agents make the hard parts of bootstrapping much easier. They can help you write the docs, shape the repo contracts, generate the scripts, wire up CI/CD, clean up infrastructure code, and keep pushing work forward while you focus on the real bottlenecks.

That is the shift.

You no longer need to design a giant “AI-native development platform” before you get value. You can start with one agent, one terminal, one control repo, and one real application. From there, the agent helps you build the very system it will later operate inside.

That is what makes this pattern so powerful: it is not heavy. It is not reserved for large teams. There is no vendor lock in who vision isn’t aligned. It is an agent-first way for a single developer to stand up a practical, self-hosted software factory without drowning in platform work first. The entire system is portable and customizable to your beliefs.

The goal is not to build the perfect system on day one. The goal is to get unblocked, get a working foundation in place, and let AI help you bootstrap the rest.

What a personal software factory actually is

A personal software factory is a text-defined, terminal-operated, self-hosted software delivery system. In the model I recommend, code and markdown are the source of truth, GitLab is the control plane, the terminal is the execution surface, Terraform defines infrastructure with Cloudflare as traffic control, a secret manager handles credentials, and coding agent(s) like Codex or Claude Code acts as the worker inside the system.

That sounds bigger than it is.

At the start, you do not need a giant platform team setup. You do not need a fleet of specialist agents. You do not need a custom web dashboard. You do not need to sandbox everything from day one. You do not need a perfect project-management layer on day one.

What you need is a setup where:

• the agent can read the repo, docs, and scripts

• the agent can work in a terminal you control

• the control plane validates and ships the real changes

• important actions leave evidence

• production is gated by policy, not vibes

That is enough to get started. We are building the platform to ship code.

The mistake people make

The most common mistake is overbuilding the control system before unblocking the work.

People jump straight to questions like:

• Should I have planner agents, reviewer agents, QA agents, and release agents?

• Do I need containers, VMs, and ephemeral runners everywhere?

• Should I build a custom orchestration dashboard?

• Do I need perfect observability before the first agent session?

Those are later questions.

Your first goal is much simpler:

Get one capable coding agent doing real work inside a controlled, text-defined workflow.

That is the bootstrapping problem.

Start with one agent type, not a zoo

One of the strongest ideas in the factory model is the single-agent-first approach. One primary coding agent type should be enough to plan, implement, review, run local checks, prepare merge requests, and follow the release path through the control plane. Specialized agents may be useful later for scale or isolation, but they are not the starting requirement.

This matters because most early AI workflows fail from unnecessary complexity, not lack of sophistication.

If one agent can:

• read your issue

• inspect your docs

• modify code

• run local checks

• open an MR

• respond to CI results

• update a runbook

Then you already have something valuable.

Your first version should be terminal-first and boring

You do not need a fancy runtime to begin.

A practical v1 looks like this:

• the human runs the coding agent in a terminal

• that terminal is on a trusted laptop or trusted SSH-accessible host

• the scope is the repo, worktree, Unix user, host network reach, and documented policy

• repo state and host caches can persist

• durable knowledge lives in repos, docs, CI artifacts, and runbooks, not the model’s memory

• skills that make agentic use easier

That host-shell-first model is not a compromise. It is the easiest setup to supervise, debug, and improve.

A lot of people try to begin with hard sandboxing, clean-room runners, custom dashboards, and multi-agent orchestration. That is usually premature. The first milestone is not “perfect isolation.” The first milestone is “the agent can actually help me ship.” The vision of your factory will become clearer as you take more action, and then you can tailor it to your needs.

Make the control plane authoritative

This is the most important design decision.

Let the agent iterate locally. Let it run tests. Let it inspect logs. Let it draft infrastructure changes. But do not treat the terminal session as the source of truth.

The control plane should own the authoritative workflow:

• build and deployment pipelines

• CI validation

• protected branch rules

• approvals

• infrastructure plan/apply

• quality control gates

• release flow

• audit evidence

In practice, that means:

• “local checks passed” is helpful, but not sufficient

• “the agent says it’s ready” is not enough

• “GitLab pipeline passed all verification jobs and the environment gate approved” is what counts

This is where a lot of agent setups go off the rails. They trust the local session too much and the system too little. The agent builds and operates the factory. The factory controls what can actually be shipped out.

The specification below will be your definitive guide.

The V1 Software Factory Specification

Read more

EXECUTIVE TAKE

The last 24 hours were more about AI infrastructure, control, and commercialization than about flashy frontier-model launches.

The clearest signals were:

• Open models are becoming a strategic hardware and ecosystem play, not just an “open source” talking point

• Agent stacks are standardizing around interoperability, evals, and budget control

• Safety/reliability work is getting more operational, especially around prompt injection and instruction priority

• AI policy is now directly shaping procurement and revenue, not just regulation headlines

Notably, no major same-day closed-model launch dominated the window. The model story was NVIDIA’s expanding open-weight push, with Nemotron 3 Super serving as the most relevant recent anchor.

TOP DEVELOPMENTS

NVIDIA hardens its open-model strategy around Nemotron 3 Super

• Filing-based reporting says NVIDIA plans to invest $26 billion over five years in open-weight AI models. Its current flagship here is Nemotron 3 Super: a 120B-total / 12B-active hybrid Mamba-Transformer MoE model with up to 1M-token context, open checkpoints, datasets, and training recipes.

• Why it matters: This is bigger than one model. NVIDIA is using open weights to strengthen its full-stack position: chips, software, inference, and developer lock-in. It also signals a stronger Western response to the pace of Chinese open-model releases.

• Sources: https://research.nvidia.com/labs/nemotron/Nemotron-3-Super/ ; https://the-decoder.com/nvidia-steps-into-the-open-source-ai-gap-that-openai-meta-and-anthropic-left-behind/

A2A Protocol ships v1.0

• The Agent-to-Agent protocol reached its first stable release, adding enterprise-oriented features including signed Agent Cards, multi-tenancy, version negotiation, and support across JSON+HTTP, gRPC, and JSON-RPC. The spec explicitly positions A2A as complementary to MCP, not a replacement.

• Why it matters: This is one of the strongest signs yet that multi-agent systems are moving toward an interoperability layer rather than staying trapped in vendor-specific silos.

• Source: https://a2a-protocol.org/latest/announcing-1.0/

OpenAI publishes IH-Challenge and ties safety training directly to agent reliability

• OpenAI published new work on instruction hierarchy and released the IH-Challenge dataset. The reported gains include better resistance to prompt injection in tool outputs and better handling of conflicting system/developer/user/tool instructions, with minimal capability regressions.

• Why it matters: This goes straight to the heart of agent deployment. As agents read web pages, parse tools, and take actions, instruction priority and prompt-injection resistance become core production requirements, not academic nice-to-haves.

• Source: https://openai.com/index/instruction-hierarchy-challenge/

Anthropic’s Pentagon fight becomes a live procurement and revenue story

• Reuters reported that Anthropic asked an appeals court to stay the Pentagon’s supply-chain-risk designation, warning the move could cost hundreds of millions to multiple billions of dollars in 2026 revenue. Reuters also reported the Pentagon CTO said there was “no chance” of renewed negotiations.

• Why it matters: AI guardrails are now materially affecting defense access, enterprise confidence, and vendor selection. This is policy turning into procurement power.

• Sources: https://www.reuters.com/technology/anthropic-seeks-court-stay-pentagon-supply-chain-risk-designation-2026-03-12/ ; https://www.reuters.com/technology/pentagon-cto-says-no-chance-renewed-anthropic-negotiations-cnbc-interview-2026-03-12/

Grammarly pulls its author-impersonation AI feature after backlash

• Grammarly/Superhuman removed its “Expert Review” feature after backlash and litigation over AI personas modeled on named writers and experts, including Stephen King and Carl Sagan. The CEO publicly apologized and said the approach would be redesigned.

• Why it matters: Identity, consent, and “persona rights” are becoming direct product and legal risks. Expect tighter scrutiny on voice/style simulation features across consumer and enterprise AI products.

• Source: https://www.bbc.com/news/articles/cx28v08jpe7o

PATTERN SIGNALS

• Interoperability is becoming its own layer. A2A v1.0 formalizes agent-to-agent communication, while newer tools like Mozzie lean on ACP/CLI orchestration for multi-agent coding workflows. The stack is separating into: MCP for tools/context, A2A for agent coordination, and local orchestrators on top. Sources: https://a2a-protocol.org/latest/announcing-1.0/ ; https://github.com/usemozzie/mozzie

• Public benchmark theater is losing credibility. Cursor’s latest write-up argues public coding benchmarks are increasingly saturated, contaminated, or misaligned, and says real-session offline evals plus live online evals track developer value better. That is where serious buyers should expect the market to move. Sources: https://cursor.com/blog/cursorbench ; https://news.ycombinator.com/item?id=47364669

• Cost control is now a product feature, not a finance afterthought. Prompt-caching tools are pitching token savings as a headline value proposition, while agent platforms like Argus expose hourly/daily token budgets and reserve capacity for high-priority investigations. Sources: https://prompt-caching.ai/ ; https://github.com/flightlesstux/prompt-caching ; https://github.com/precious112/Argus

• Human approval remains a winning design pattern for operational agents. Argus explicitly uses autonomous investigation plus approve-before-execute remediation. That hybrid pattern continues to look like the most enterprise-ready path for infrastructure, security, and workflow agents. Source: https://github.com/precious112/Argus

• Open weights are increasingly strategic rather than ideological. NVIDIA’s open-model posture appears aimed at keeping developers and enterprises inside its compute ecosystem. Expect more “open enough to attract builders, optimized enough to favor my stack” behavior from major vendors. Sources: https://research.nvidia.com/labs/nemotron/Nemotron-3-Super/ ; https://the-decoder.com/nvidia-steps-into-the-open-source-ai-gap-that-openai-meta-and-anthropic-left-behind/

AI BUSINESS NEWS

• Credible but not independently confirmed by ByteDance: Reuters, citing the Wall Street Journal, said ByteDance is building offshore AI capacity in Malaysia via Aolani Cloud, reportedly around 500 NVIDIA Blackwell systems or roughly 36,000 B200 chips, with likely cost above $2.5 billion. If accurate, this is a major export-control and competitive signal. Source: https://www.reuters.com/world/asia-pacific/chinas-bytedance-gets-access-top-nvidia-ai-chips-wsj-reports-2026-03-13/

• NVIDIA’s GTC preview is already framing next week’s narrative around agentic AI, inference, physical AI, and open models. It also highlighted “Build-a-Claw” and an OpenClaw playbook for local-first agents on DGX Spark, a sign that always-on personal/workflow agents are moving into mainstream conference positioning. Source: https://blogs.nvidia.com/blog/gtc-2026-news/

• OpenAI Developers posted a high-engagement Codex app update on X, highlighting new personalization options including theme import/share. It is a small product change, but it reinforces continued investment in persistent developer-agent UX rather than just model endpoints. Source:

• Useful tools/software flow remained strong on HN and GitHub:prompt-caching: Anthropic prompt-cache observability and automatic breakpoint placement.

  • Mozzie: local-first desktop orchestrator for Codex, Claude Code, and Gemini using worktrees and parallel agents.

    • Sources:

      • https://github.com/usemozzie/mozzie

      • https://news.ycombinator.com/item?id=47355451

  • chat.nvim v1.4.0: Neovim assistant adding Anthropic, Gemini, Ollama, and chat bridge integrations.

    • Sources:

      • https://github.com/wsdjeg/chat.nvim/releases/tag/v1.4.0

      • https://news.ycombinator.com/item?id=47363926

  • Argus: open-source observability agent with ReAct-based anomaly investigation, human approval, and token budgets.

    • Sources:

      • https://github.com/precious112/Argus

      • https://news.ycombinator.com/item?id=47364724

WATCH ITEMS

• ByteDance/NVIDIA offshore compute: credible report, but still a second-hand report and a likely magnet for export-control scrutiny. Source: https://www.reuters.com/world/asia-pacific/chinas-bytedance-gets-access-top-nvidia-ai-chips-wsj-reports-2026-03-13/

• A2A adoption velocity: v1.0 matters only if major vendors and enterprise platforms actually ship around it. Watch for SDKs, hosted runtimes, and cloud workflow support in the next few weeks. Source: https://a2a-protocol.org/latest/announcing-1.0/

• Anthropic/Pentagon spillover: the core question is whether this remains a defense-specific dispute or starts influencing broader commercial procurement and trust assessments. Sources: Reuters links above.

• GTC next week: NVIDIA has clearly pre-positioned agentic AI and open models as central themes. More concrete announcements are likely imminent. Source: https://blogs.nvidia.com/blog/gtc-2026-news/

BOTTOM LINE

Read more

“There’s levels to this” - Meek Mill

That’s my current belief of Agentic Coding right now. For every new person still painstakingly working in IDEs instructing their Agent one file at a time, there are people who have entire automated coding workflows going on right now (just check out clawdbot or Linear). We’ve hit escape velocity for Agentic Coding as we can scale coding agents that are high quality right now. Not enough people have noticed, but the successful people, the people who know how to pivot and be consistently productive, have noticed and are now building 12 coding projects around the clock with minimal oversight.

This article will introduce how to run multiple projects semi-autonomously all in the terminal and require just basic prompting to accomplish our project goals. This gets our Codex skills upgraded from beginner to intermediate, with room to run to expert as you scale agents out. By the end you’ll have:

• one bash script = full workspace interface setup

• one zellij tab = one organized project context to work in

• notifications when the agent finishes its work

• global agent rules so every repo behaves the same

We’ve previously talked about getting started with OpenAI’s Agentic Coder in Codex, if you have not read it, check it out first.

In this article I am going to share my simple terminal and shell setup with Codex that will help optimize your setup so that it scales up to build multiple projects at once. We will be building a terminal based workflow that has an easy load UI using Zellij to load all CLI tools into the same Tab and then having multiple tabs per Vibe\Agentic coded project. We will tweak Codex a bit more with better configuration so that it operates better across projects. Then I will show you a small project I made for Mac that gives native notifications when Codex finishes its turn. Let’s begin.

Read more

Learning these tools will transform your productivity as a solo creator into a one man army when it comes to building out projects rapidly. Let’s get started.

Open AI Codex

I’ve recently checked out OpenAI Codex since I really enjoy using ChatGPT as my main source of technical answers, troubleshooting, high level planning, and detailed implementation designs. I’ve found for a few years now that OpenAI makes their tools fairly consistent and high quality when it comes to programming implementation, and the release of their CLI interface for Codex inspired me to finally dive into CLI based agentic coding, where before I was using integrated extensions in my visual studio code like Roo Code and Github Copilot. This was a more recent development, and after trying it to port a few projects between languages, I was really shocked how incredible the tool was. I had a NodeJs project that was a proof of concept and experimental, and I ported it to C# and refactored the database layer with it. With all this, I have a new project running on a much cleaner design and I did it all with Codex doing 95% of the work.

As far as the benefits from CLI based agentic coding vs some sort of GUI, I can’t fully explain if there is a major benefit from a technical perspective. However I do find that most 1st party apps the experience is generally better than a 3rd party approach, especially as we are still in the storming phase of agentic coding. OpenAI has integrated Codex tightly with their AI models and I’d imagine there is an efficiency in there from a model and model use perspective. While I do love Roo Code and it’s incredible feature set, it does also seem to chew through tokens a bit inefficiently it seems, and since I use OpenRouter as the provider which means I cost myself a lot of money in token usage. To me, something with tool usage and file system browsing seems to be better in Codex and is also more efficient on token usage, which matters if you start scaling your Codex use since every token is a direct cost to your wallet.

As far as CLI vs Non CLI, the CLI experience is really sublime and saying CLI is a bit disingenuous to what the full experience is. Codex is essentially a full on application just presented in the terminal for you. I find it beautiful and simple in its display and feedback of what it is working on. It’s a real pleasure to use and since it’s terminal based, you don’t have a lock in with VS Code or another IDE’s custom GUI interface, and it’s highly portable and universal, being just a nodejs application. I’ve never felt limited in it being a terminal application ever since using it, since all it really is is a glorified chat session.There’s also some sort of brain switch that happens when coding when you’re going through the command line versus your Visual Studio Code that maybe makes you think better or differently. Hard to explain but it’s the same reason some people work better at a designated work desk versus a random table somewhere. I’ve mentioned in previous articles I feel it’s important to cultivate a location as a productive zone with the corresponding aesthetic, and this is just an extension of that, just in a virtual world rather than physical.

Before we get started, even if you don’t use Codex, there are some general software engineering patterns below that will help any agentic coder (ex: Claude Code), even if you use a different agent to perform the work. A lot of what we discuss is further on is really just the engineering design mindset applied, and that is universal regardless of who or what codes the software.

Read more

Homelabs are a continuous journey with frequent waypoints and rarely have a final stopping point.

This is my main takeaway from the last year of building out my own personal cloud setup at home. What is time consuming, annoying, and frustrating eventually turns into a great reward when systems are in place. Once you hit a critical threshold of work put into the homelab, everything else suddenly slots into place and what becomes a time sink becomes a positive feedback system, where everything builds on itself to becomes a self sufficient aid to your everyday digital life.

I started a homelab journey over a year ago when deciding to build out a NAS along with an AI Server. You can see the results of that here:

Since then I have added new hardware and software to my deployments and now feel like my homelab is now a net benefit over the amount of time I spent setting everything up. This was a major relief, since those weekend days and nights felt almost pointless at times, often stuck on the command line configuring something that wouldn’t work, ready to pay the $10 per month for life tithe to the SaaS gods for a comfy day. However I stuck with it, and like most things, the breakthrough does happen and the information crystallizes into actual knowledge, which then lets you execute. That’s why a homelab is for, making your life better, whether it’s for entertainment or for data sovereignty.

I recently realized the power of my setup when I was playing around with my Meshtastic radios and needed a MQTT server to demo thing that functionality out. I realized I can just deploy a docker container on my unRaid box in a few seconds, setup the radio to communicate over my bluetooth to the MQTT container, and then hook up a client on my Mac to check out the traffic. It didn’t work perfectly, but I was able to take an idea into action in just a few minutes with my network setup easily accommodating. I didn’t have to sign up for some service or give away my personal info or data for any of this.

Another example was getting Telegraf setup on my AI server for hardware metrics shown over Grafana. I wanted a nice dashboard I could use to monitor my CPU, RAM, and GPU usage when gaming or running AI inference. I installed Telegraf on my Desktop to ship the data, configured InfluxDB for a time series db, and then visualized with Grafana, all as docker containers to take the data and process it. In a few hours I had full metrics being shipped on my personal devices with all the flexibility Grafana gives to query and display data in beautiful ways.

The key to everything here is set it and forget it automation, diligent note taking, a healthy dose of AI troubleshooting, of course docker containers. Once I got these practices down, it was easy to expand the setup more and not stress about maintenance burdens. I don’t spend a ton of time on the lab now and mostly just use the applications I have, but I can expand capabilities if needed once I find a new idea or niche to explore into. Even when I do spend time on it, it’s now fun! I have a true self hosted platform that I enjoy tinkering with.

Homelabs can take many shapes and sizes, so everything I offer here won’t be perfect for your situation, but I hope you can learn a few things and implement them on your own end, or even inspire you to start your homelab journey.

Let’s dive into the key takeaways on how to make our lives easier.

Read more

Read more

If you need even more performance out of your Local AI then we need to shift to more powerful AI backends to run our models. More tokens per second means we can get answers faster and iterate sooner, letting us develop our knowledge, code, agents, or whatever else to do more in less time. I’ve strongly recommended Ollama to everyone here as it has the simplest setup starting from nothing for beginners and runs on Windows, Linux, and Mac easily and you don’t have to perfectly optimize it for your system, but for our next evolution we are going to use Llama.cpp to further enhance our AI performance and also gain access to more models on HuggingFace.

Llama.cpp is a project to create a faster backend for Facebook’s Llama based models written from the ground up in C++. It has many configurations and build options to suit a variety of hardware and generally performs inference faster, up to 1.8 times the performance. Additionally, if you are on Mac Llama.cpp supports the MLX framework as a primary goal, so this is ideal for you also for the best performance. While not as simple as Ollama, it offers access to a lot more models than Ollama does due to the HuggingFace community.

Models and Quantization

When new models are published on HuggingFace they are published with full precision 300GB+ safetensor files, but recent releases like DeepSeek R1 reached up to 600GB! These are not easily useable to the average consumer hardware public due to the size and the cost it would require to run them, so members of the community convert them to formats like GGUFs to make them smaller. The process of converting them to GGUFs allows other consumer backends to understand, like Ollama, llama.cpp, etc... In addition to changing the format they also quantize them, meaning they strip away some of the precision of the model to lower the size of the model. This sacrifice of precision makes it so that the model can run on less powerful hardware, but gain the ability run the model on lower RAM as needed. Since most consumers don’t have server grade GPU clusters, we typically have to use these quantized models to run on our GPUS or Macs.

Think of this in terms of the music file formats. Music in .WAV are fully uncompressed audio, meaning the highest quality, but as a result gives massive file sizes as they are uncompressed. This is good for audio engineers making music who have high end equipment, but not for the average music listener who might just listen on a bluetooth speaker. Even a conversion to FLAC saves an immense amount of space on disk without sacrificing the audio quality for the user via compression. We could keep compressing the audio down to .mp3s and most people might not notice the difference but also save GBs of space on their mobile device. This is similar to how quantization is, yet each stage of quantization is much more noticeable than the human ear is to music quality. Some models when quantized spit gibberish at high levels of quantization as that removes the precision needed to answer correctly. The Tensors or “weights” of the models are essentially just massive amounts of matrix multiplications, with each cell containing FP32 numbers as shown below.

As we quantize down, we start lopping off the precision of this number. When we perform inference on LLMs after sending them our text in chat, it essentially performs an operation chaining together the most likely answer using these matrix multiplications to figure out the “correct” response, based upon the weights. So less precise weights = less precise answers, generally speaking. But a good quantization can still result in excellent result for the average consumer, and that’s why so much effort goes into this and enables Local AI. A less precise model, even running locally, can still yield excellent results to enable whatever you wish to do. As a caveat, there are limits to the amount of quantization you can do when working with different models sizes as you can see in the first graph in this post. Basically the smaller the parameters of the models, the less useful it is to quantize to certain amounts. This is essentially diminishing returns in regards to the model’s trained parameters and the loss of precision tradeoff.

In regards to Ollama and LLama.cpp, both use the GGUF model format to work with their backend. LLama.cpp can directly use GGUFS, while Ollama has another step involving a modelfile and the GGUF that needs to be made, so that’s additional effort needed for someone to do and then upload specifically on Ollama’s site. The modelfile models after Dockerfiles, and you can see the layers being made as you download a model, so it’s essentially a layered file system combined with the GGUF. The modelfile encodes things like the default chat template, signatures, config parameters, and other things, so you’re sort of up to the mercy of the person who writes this model file, though I believe most things can be overridden at runtime, or reconfigured if needed. One key note is this is one way to set the context size of your model via num_ctx. Whoever makes this modelfile can set this parameter, meaning if you need high amounts of context, you must adjust this to get better context. Since there’s a default context of 2048, you might hit that limit easily by accident and not know!

This video below explains more of the modelfile process with Ollama.

Since Ollama’s community is smaller then HuggingFace’s it will often take longer to get the model of your choice available if it’s new. The difference might be a few days, but if that matters to you then I would suggest to use Llama.cpp more. Additionally, add in quantization steps and it can be hard to get more specific models and their quants in Ollama available to you without getting your hands dirty. Backends like Llama.cpp will often have first dibs on newer models such as the recent DeepSeek R1 due to the massive amount of traffic HF gets and the large amount of users who are happy to quantize and upload models for us. HF also provides tools to do the quantization for you, making the process fast once a new model drops. Huggingface also contains many more models types and varieties than Ollama typically would. Add in the performance gains while trading some of the simplicity and you have a superior backend for hosting models in a more performany manner locally. I highly suggest if you want the best out of your models locally to switch over to a more performant backend such as Llama.cpp (or vLLM, exLlamav2), but that’s another post one day). Now that the differences between the two have been explained, lets go over setting up Llama.cpp.

Running Llama.cpp From Scratch

For this example we will be compiling Llama.cpp from scratch as a way to always get the latest features but more importantly understand how and why the software is built. Most of the time when we use a CLI tool, we don’t necessarily care about the underlying implementation or build process, but AI backends have many complexities when it comes to compiling for different hardware and their supported drivers/frameworks. This, along with the tuning model with config options will affect performance, that’s why I think it’s important to build it from scratch to learn much more about the software, otherwise you might get lost once you run into an issue.

Read more

When I first decided to launch a paid Substack, I was nervous and thought I was not good enough. But I decided to forge ahead and no matter what I knew I’d learn some things. It turns out I had a really strong reception to my articles talking about productivity enhancements such as below.

We covered your building your workspace correctly with desk, chairs, monitors, and more, and then covered spiritual health, shell and terminal setups, and shifted into more AI content such as building your own Coding assistants, hosting Local AI, and Building your own NAS. We also covered extra things like building remote network access, which then combined with my Local AI and NAS setups to get AI and your local self hosted services anywhere in the world, safe and securely.

I have more content on the way this year that will help you be an even better and faster worker and I ask everyone here to sign up for the paid membership to support me and these articles you make you better. Cheers to 2024 and heres to a great 2025!

Article Recaps

If you’re new here or missed earlier articles, here is everything I published in 2024. As we go into 2025, lets refresh what we learned and hit the ground running so we can accomplish all our goals in 2025. Each topic is listed in chronological order if you wish to recap in order of publication.

Productivity Series

Local AI Series

Everything Else

Read more

Recently I was able to tie both servers together and I felt a great joy in building my home lab that I wanted to share with everyone here to give people ideas on how local hardware is a great alternative to invest in and avoid privacy invasive SaaS companies and high prices of storage and services.

Defining the Problem and Constraints

Initially the decision I was leaning on was to build a new AI server and also combine a NAS into it. I had a poorman’s NAS with just a Window Drive network shared over the network residing on my AI Server. It work for some basic file sharing, however this PC had consistency issues. It would often randomly restart and get stuck on the BIOS before needing a manual push button restart. This was immensely annoying since I would often RDP in at random times only to find out I had to restart the PC. Also I noticed as I started getting into AI code and tensor code that build times were pretty bad. I was rocking an intel 6700-K and the age was really showing itself when compiling software. This demotivated me from working on AI as much since a slow compile is a frustrating experience (don’t tell Rust people this). A golden rule for Servers is that they should always be highly available since you never know when you’ll need to use them, and you need to have the trust that a service running on them will always be there when you need it. The PC was also headless, meaning there was no monitor or keyboard attached to it. So any non trivial level of troubleshooting required me to find a monitor and peripherals to attach to it. Since my AI server resided on this hardware it often meant my GPU was unavailable too, causing more issues. Overall it was a bad experience that was getting worse.

My initial thought on this was to save money and just combine the hardware upgrades into one computer as I had done previously. Pop a new motherboard, RAM, CPU, and be done with it. But after some research I quickly realized this was a mistake. But like most things, being cheap often causes more pain in the future.

Read more

Read more

Baseline Mindset

Lets do a quick run through of my journey on Local AI.

When I first started out with AI I started exploring with Stable Diffusion around two years ago running AUTOMATIC1111 with my old Nvidia 1060 6GB. It took over 30 seconds just to generate an image on pre SDXL based models. This was the start of my journey on the hardware impacts when utilizing these AI models locally from my own machines. It was a painful and time consuming process but also fun to see a new technology in motion. At the time I was such a novice and didn’t understand prompting well so I would iterate 20 times for every prompt so I could get a good sampling of pictures to choose from. Now with my 3090 I can use the latest SDXL models and generate images in seconds. I tell this story to highlight how awesome it is to have fast AI, and to have fast AI you need to great hardware and software.

I dropped off the AI train for a bit, only to come back with summer ChatGPT3 launch rekindling my interests in the topic. This was great, but it wasn’t local, there were no privacy guarantees, and OpenAI can’t be trusted with sensitive data. Once I learned how easy it was to run Ollama on my Mac earlier in 2024 I started running AI on my personal devices and realized the true power aligned hardware and software resulting in blazing fast operations.

The speed was thanks to Mac’s hardware and software design for Apple Silicon. Our favorite local AI software Ollama runs with llama.cpp library, which treats Apple’s Metal API and MLX framework as a first class option. MLX is machine learning library that is highly aligned to Apple’s GPU and CPU hardware capabilities. These benefits return to Ollama by utilizing all the hardware that the Mac can provide under the new M generation chips. This means that the entire RAM and significant processing power are available without needing discrete external GPUs like with AMD, Nvidia, and Intel GPU lines. Suddenly I was running 8GB-13GB sized models and having conversations with AI that rivaled the speed and quality of ChatGPT 3.0 and 3.5 all with a few command line commands. I could now have full chat and also inline code suggestions all on the same device. This is where I realized the power of the local AI but also again hit my limitations.

My Mac wasn’t bought for AI, but thankfully I bought the 18GB model M3 model. For small AI models they run from 8-16GB of your RAM. This can unfortunately starve the rest of your Mac for memory if running a larger model. Throw in a Browser with many tabs, a large code repo inside an IDE, plus many other apps, and suddenly you’ve tied up a lot of system resources and can’t operate as fast.

This led me to my current day situation. I retrofitted my old desktop with a new 3090 and even though the RAM and CPU (Intel Core i5-6600K) are years old running Windows, everything with AI was suddenly immediately available and immensely more productive. I can now run Stable Diffusion XL and the latest Llama 3.1 all on this server and not tie up my MacBook’s RAM, focusing my resources into my Coding environment now. I now have superior models and processing power all an API call away on my server (more here on that) while saving my Mac most of the hard lifting.

After all this I’ve learned a lot of lessons from this slow evolution and I’m going to share with you some learnings and give you options on how to proceed. This will save you time and money and get you up to speed.

Why Does Hardware Matter?

Read more

Today we are going to continue our series on Local AI and make it available outside of our home network. This gives us our personal AI models that are privately hosted on our own hardware the ability to work with us at the coffee shop, at the airport, and anywhere else you need to travel outside of your home network. We can continue to focus on our privacy oriented setups that protect us from data mining and intrusion into our personal lives from the larger hosted AI companies while ensuring we have a secure connection to our home network that other people can’t access.

This allows us to continue to use AI productively without feeling the need to use other less privacy focused services while we are on the go. Most commonly this happens when using AI on our phones, but this will also work for any devices you have as long as you can use WireGuard. As a bonus this technique can be used on any other self hosted software also to reach it on the go, but for this article we are going to focus on locally hosted AI.

Prerequisites

This article builds on a few others that need to be done before jumping in here.

First you need to get Ollama up on your server you have chosen, see Running AI Locally and Privately for Free. Ensure that after you have Ollama setup with the 0.0.0.0 IP address so that it serves on the network and not just on the loopback interface. You can test this by trying to access the Ollama API on a different device with the server’s IP address and ensure you have a successful connection.

Read more

Merge Requests are your critical methodology of working well as a group in software projects. They contain everything that is needed in order to push a software project forward and if you want to have a successful project you need a robust and streamlined process. You will make thousands of Merge Requests over your lifespan and getting the process right for yourself will save you time and frustration along with your teammates.

The merge process will contain your code which is the most critical asset, however it is not the most critical point of get code merged oddly enough. Why? Merge Requests are social signaling via knowledge sharing. It’s someone saying I made this code, and I’d like to combine it with the existing code, and here’s how I did it. You are putting your code into the mercy of the reviewers of the code repository and only with their approval may you get in. Viewing it in this lens should change how you feel about the process now. It’s not just about the code, it’s about the entire presentation of your merge request. If your presentation is terrible and unclear you will get rejected for a variety of reasons. Even if your code is perfect from a technical standpoint many things can stall or even sink your merge. This could be a failure to explain the changes, not filling out required fields in the template, no links to a ticket with business justification, an inability follow the code conventions, or just an inability to format the code correctly. I often have people submit MRs to my projects and they just ignore the entire template, don’t link tickets, and plenty of other issues. This requires me to take time out of my day to repeat things they are unfamiliar with and hand hold them to get their code in. We can streamline this process so that we spend less time reviewing MRs and also make the burden less on the committer.

In this article we will discuss what are necessary components for a Merge Request, examples of a good one, and some tips for creating merge templates so that your team can follow. I will also discuss some good practices to set your repo up in Gitlab so that you can incorporate these changes into your development lifecycle. By applying all these techniques we can save everyone on the team more time by getting code merged faster and allowing you to finishing your work faster.

Basic of a Merge Request

The structure of your merge request is going to heavily depend on the process put in place by your org. The most standard ones days are based around Github and Gitlab styles, but there are also older styles done via Gerrit or TFS. I’m going to focus on the former since those are much more popular and specifically use Gitlab as my demo vehicle. These use Markdown as the syntax which enables a rich document to share with your team. Most well established companies will have existing established conventions to follow and if you don’t follow them you will be denied or stuck in MR purgatory. You can see Google’s process here for some inspiration at the Enterprise level. Your hand will be held in this process, so just follow everything the team asks of you as best as you can and you will not have an issue as long as the code is good.

Many smaller companies or open source projects keep it much looser as a process and that is where we will try to focus on for this. Know that the Merge Request process should seek to provide extreme clarity to the reviewer, share knowledge out, and also make the product better, so focus on that when creating the request. Your MR will be an all encompassing technical document that contains all the following information for the reviewer to make an informed approval.

An overall description of the work

This tells the high level story of your work. Do not get too technical here as the code should primarily speak for itself if you follow good coding conventions like “Clean Code”. I prefer to leave my own comments on the MR itself to guide the reviewer towards clarity as that keeps the context local and therefore easier to understand. Here are some things to focus on in this section:

• It will note critical ideas of the story to look for

  • EX: “Changing Database access to use environment based credentials instead of hard coded ones”

  • EX: “Update the styling on the main menu to not overflow on narrow screens”

• If a non trivial change, a link to your ticketing system with the business requirements

• Links to any design documents you made. If you have a complex change set including diagrams and low level designs are a must

• Action items other team members must do, due to a new process, breaking changes, or testing requirements

• Links to related MRs and also reference documents used, such as MDN docs, language docs, and other key reference points or blogs

Proof of working functionality

Usually this is a before and after picture or a live site for users to look at and confirm with their own eyes. I’ve been burned before by something being “fixed” but it actually never was. Trust, but verify always.

• For UI work with would be screenshots or a video showing the fix embedded into the MR doc.

• For non visual based work, this could be many things:

  • API work: screenshots of an HTTP request/response showing it works from Postman or the Browser, or .HARs of the process, or JSON responses

  • CI/CD work: A link to a passing pipeline with the fix or new stage

  • Infrastructure work: A link to the new resources created and/or fixed in AWS or your own server environment work. For terraform this could be the generated Terraform plan pasted into the MR.

  • Systems Work:

    • A example of an Event passing through the system being processed successfully at every stage.

    • An updated IAM policy that fixes a Service

    • For AWS I will post Cloudwatch logs, the SNS message or SQS message that was processed, the new Dynamodb entry, and many other things. Almost every service in AWS has some sort of method of tracking and logs and these will be useful to send to your peers.

  • Deployment Environment work: copies of shell scripts ran, screenshots of the updated /bin folder, updated apache config, etc..

  • Database work: Example of a new table being created or modified

• General screenshots or data samples that allow the reviewer to also confirm that the code works as expected. I go screenshot heavy on my PRs as that is my “Proof of Work”.

Test Cases and Steps to Reproduce

This should be mostly a list of bullet points. This is my own personal favorite section when doing MRs as is it where I double check my work and ensure I covered all my bases for the requirements. If a business requirement isn’t included as a test case somehow that is a MR “code smell” and you will have any developer worth their salt call you out on this.

• This section is really critical for me as I often reference older PRs as a way to retest work and confirm prior assumptions of the system

• This allows you to get into the mindset of the developer and ensure they have covered every code path

• This is the committer’s attempt to also prove they tested their work correctly per the business requirements and also ensure no degradation of the system

• Will often focus on manual testing and higher level acceptance testing and E2E testing here as unit tests and integration tests are mostly self documenting in the code review

• I try to include raw data here as needed as, often I need a specific JSON structure to test something and having it handy will save me and others time.

Merge Request Checklist

This section will include many of the code review workflow processes to help committer ensure they are following the rules of the repo. Often it will be a checklist you can click off on while creating your MR, but keep in mind MRs are living documents and not everything can be accomplished immediately. It takes time to run tests, have the documentation team write their updates, have the significant stakeholder sign off such as security team members or product managers approve.

Some things will be simple such as:

• Formatted the code per repo styles

• Updated library version (if required)

• Pipeline passes successfully

• Follow up E2E story created

• Dependencies are up to date

• Added appropriate unit tests

Outside of this there will also be specifics on how your organization and specific repo operates. This is where other teams or stakeholders who need to sign off will include their particular needs. This also depends on the type of development work being done. An application developer workload will be different from what a security or networking engineer works on, so adjust the process accordingly. I do fullstack dev so I have to think of the many issues up and down the stack and ensure that the MR process covers those cases. Monorepos will often have significant amount of checks and templates to prevent regression and ensure quality, where as a more targeted repo such as a frontend repo will have less.

Merge Request Assignees

Who you assign a MR to is important. If you have a unified team that works together on most things then you can just assign it to everyone or have a sensible default. Often most repos will have a default and you can just do that, plus add any additional key stakeholders if needed.

Often there are large teams that do silo’d work that we don’t want to annoy. Be tactical here if you have discretion and don’t add everyone. People’s review styles are all different and I know some engineers will nit me to death over silly things, so I often exclude those people as it just makes the process tedious. You should ensure to have a technical expert to review your code and often this person will be the default. If you’re merging code after two juniors sign off you might get some questions from management if your code breaks. Keep in mind MRs are historical records once merged and this can be used against you if something goes wrong, so be careful LGTM comments.

Code Reviews are not a punishment and if you have good teammates they will point out flaws that should be happily fixed. Keep a professional tone always as everyone can see how you act. MRs should be collaborative, not combative on a healthy and well functioning team. If you experience significant pushback you most likely have not cleared a design with the team or your approach is flawed. Try to fight those battles before you write code and not after to save you time.

Real World Example

To make things more real lets look at a real MR on Gitlab’s repo. Ignore all the labels and extra fluff and the automated processes, let’s just focus on the core document.

You can see they clearly give a description of the issue, link to other MRs for context, and describe why they did things a certain way. There are screenshots for proof of work and also code samples on how to validate the feature works as expected. They assigned only two reviewers who both signed off and appear to be the knowledge experts.

This is pretty simple as far as MR docs go, but the code change matches that, which is a good indication. You should scale your MR doc to the level of complexity and changes that are required in order to ease the minds of the reviewers. A 50+ file change of a complex changeset will require a lot more careful review than a single line change, so make the life easy for your reviewers and give them the clarity they need in the MR. There is also a link to a code quality checklist for the committer to review.

Overall this simple but clean example is a good way to get started if you don’t have a process. I would investigate other public Git repos such as Microsoft if you need more inspiration besides this example.

A Sample MR Template

Below is a sample markdown file you can add to your repo under .gitlab/merge_request_templates folder that you can force upon users. Gitlab explains how this process works here. I highly encourage this as it makes is so your MRs are consistent in formatting and also that you don’t have to recreate this template by hand on every MR.

## Summary
Provide a brief description of the features or fixes included in this merge request. Explain the motivation behind these changes and how they impact the project.

## Testing Instructions
Detail the steps required to test the changes introduced in this merge request. Include any relevant scripts, commands, or links to resources needed to perform the testing.

### Automated Tests
- [ ] Ensure all existing automated tests pass
- [ ] Add new automated tests for all new features and bug fixes

### Manual Testing
- [ ] Describe any manual testing steps if applicable

## TODOs
Here's a checklist of common code review checks to ensure quality and consistency in the codebase:

- [ ] Code follows the coding standards and style guides of the project
- [ ] All dependencies are properly managed and up to date
- [ ] Security implications have been considered
- [ ] Code is properly commented and documentation updated
- [ ] All new and modified functionality has been thoroughly tested
- [ ] Performance implications have been considered

## Assignments
Assign team members to specific tasks or roles within this merge request. Tag each assigned team member.

- **Code Review:** @username1
- **Testing:** @username2
- **Documentation:** @username3

## Additional Notes
Include any other relevant information or context that reviewers might need. This could be related to deployment considerations, potential conflicts with other branches, or areas where you would specifically like feedback.

## Screenshots
If applicable, add screenshots to help explain your changes and showcase the UI modifications.

---

Please review the above checklist and provide your feedback. Thank you!

You can also assign default reviewers by adding the text to the template above:

/assign_reviewer @user1 @user2 @user3

This is particularly great if you work in a mono repo and have different types of PRs depending on the workload and only want to assign to certain people. You can see more commands to add into your MRs here.

Other Tips

Finally here are some additional guidelines to setup in your repo to make MRs more manageable. Your git host should have equivalent solutions and I suggest you worth with your team to identify where the pain points in the review process are.

Are people sending unformatted code? Make the build fail and block the merge.

Are people’s code out of date? Require their MR to be merged or rebase to the latest master before merge.

Here are some more rapid fire ones:

• Require pipeline to pass to Merge

  • Codify expectations of code into the build pipeline.

    • Almost every language has a de facto CLI tool to format code that can be configured to the team style

  • Fail builds fast if the MR isn’t acceptable. Can fail on formatting, build, unit tests, and more.

• Require approval minimums from mid level or higher devs

  • Ensures that juniors have atleast one person watching them

• Enforce default templates on MRs

  • This helps external team members too

• Enforce default merge style on MRs

  • I prefer squash merge for clean history

• Enforce Fast Forward Merge with required Squash

  • This removes merge commits and makes the history easier to understand

  • Squash ensures that many small commits do not pollute the history

  • You can do a Rebase focused pull to update code. This can be operated in the Gitlab UI also without the CLI to save time.

• Use Draft status to clearly indicate work in progress

  • I often do this as an optional code review for people

• Close MRs that need rework to clear the queue to reviewers

  • Sometimes our initial approach isn’t the best. I like to close MRs that require significant rework to unclutter the MR timeline. This is more of a personal preference.

• If working in a large codebase with many people use Code Owners to ensure no stealth edits of your code.

• Any extended back and forth on a code review can be moved to a quick call. This is often less painful then commenting and waiting 30 minutes every time for a response.

  • Just ensure the resolution is summarized in a followup comment

• Don’t be afraid to modify your merge template, it’s version controlled and experimentation should be encouraged! Find the best process for your team.

• Require more approvals for Merges that lower Code Coverage

Summary

The key takeaway of this article is that your MR’s need to be clear and concise with a focus on sharing knowledge to your team without bogging them down. The less painful this process is will result in faster iterations for your software project. Work together as a software team to build sensible defaults into the MR process and automate as much as you can so that people don’t have to be broken records fixing easy mistakes. By following the advice in this post you can make your life and every else’s life better when it comes time to merge code. If you’re submitting multiple MRs a week this is a must and you will reward yourself over time by building a good process for the team.

Previously we covered setting up your Mac with Iterm2 and we are going to do the same for Windows. Windows is a more viable development platform than ever thanks to the advent of Windows Subsystem for Linux, which allows for a native linux environment but with the familiarity of Windows User Interface. We can take advantage of WSL and the other shells provided through Windows to build the ultimate Windows Terminal setup that will enhance your work on the system just as we did on Mac.

You might wonder why someone who switch to Mac would even care about setting up a Windows terminal, but the reality is I spend more time on my work laptop than my personal one, so that means my Windows setup needs to be even better based upon the ratio of time I spend at work. The better my work setup is, the faster I can accomplish the tasks for the day and then turn my attention to my personal work.

Additionally Windows and Linux based systems are the two most popular deployment environments for software which makes it a perfect OS for cross platform work. Since WSL enables a total and complete shell with a full linux Kernel but doesn’t lock you down to Linux based UIs, you get massive amounts of software compatibility suddenly with a great user experience. Even with my qualms of Windows UI going downhill I still find it better and more familiar than most Linux based interfaces. Working in Windows and then dipping into the Terminal to run things like wget, curl, jq, grep and untar to look at and process data is a common occurrence for me and having those tools easily available to me makes my job much easier. More serious tools are also available and better in Linux like terraform, aws cli, and others. File system access between the two is easy (though can be slow cross mounts) which enables fast collaboration for the two environments to swap data between. You can see a more detailed explains of the two terminals here.

Enough convincing, let’s get to setting up a Terminal on Windows that enables this!

Windows Terminal

For our terminal of choice we are going to use Windows Terminal. It is a serious project from Microsoft to have an excellent Terminal that can finally challenge Linux based ones. The built in Console for Windows is trash and offers minimal advanced usage compared to a default terminal from Mac. The original console host has little customization options for colors and themes, no tab support, unideal text buffer resizing, and just poor performance in general. There are many reasons why Window’s console is so limited in functionality but the main reason is legacy compatibility. The console needs to work the same going back to at least Windows NT , so in terms of upgrades there are not many.

As for why Windows Terminal you can see Microsoft’s own words on that. But if you’re familiar with any advanced terminals you get what you expect. Custom fonts with ligatures, themes, and backgrounds. Tab support with multiple panes, UTF-8 support with GPU rendered text for faster performance, and multiple profiles that you can set to different shells and customize them accordingly.

To get started you can download from the…. Windows Store. Yes this is terrible but it’s a UWP app so you will want if you want automatic updates you have to go through the store or compile from source on their github repo. I download from the Store since it’s easy and it is for the work PC but if you’re turbo go ahead and compile from source. After install it will launch for you and you will be in the terminal.

Depending on your existing system setup you may be launched into a different shell than the one you see here. I have Powershell Core installed which is the ideal default shell for me. Using the Arrow dropdown next to the new tab icon you can select a different shell for now. Sometimes I actually need to use cmd.exe and regular Powershell so this is a great feature if you work in varying shell environments. Some older tech companies still have legacy processes that rely on these older shells and this will help you out and get you off using the default console host and keep your sanity.

If you have WSL installed you will also see an option for every distro you have here. I don’t need all these shells of course, so if you click on Settings in the drop down you can select the profile and then scroll to the bottom and select “Hide Profile from Dropdown”. Additionally I like to setup an Admin profile for my Windows Shells. You can do this easily in the Profile section of Settings Menu, scrolling down to “Add a new profile”, and then duplicating the desired shell, and then enabling Admin launcher in the profile settings and also renaming the profile to have Admin in it. Our end result is the following:

To bring it all together, we installed Windows Terminal, have access to a profile per shell type, a shell for Admin access, and a shell for our Linux distro! Already we have an immense productivity by hosting all these shells (and operating systems!) under one app within the Terminal. Often I will have one of each opened up and swap between them as needed. I will use Powershell for Windows operations and basic file system navigation and scripts and WSL for items and tools that are better are native Linux.

We can continue to add profiles as needed if we have different workloads, and we can also modify the launch command if we have a specific switch or command line param we wish to pass to the shell. For WSL this could mean launching a different user and to a different directory instead of the default one by customizing the cmd line command. To do so, clone the linux based profile you want and edit the “Command Line Section” as below.

Read more

Your profession as a software engineer is a craft.

A craft needs a deliberate methodology and operation to build and create along the entire path to a completed work. For physical crafters they use a workshop and toolbox along with materials that aligns with their expected workloads to work intelligently and efficiently in a process that ensures quality results.

The digital equivalent for a software developer are the Personal Computer and its applications, terminal, and shell inside the PC. These tools need align with your daily work so that you can get more done, correctly, in less time. When you configure your software workshop correctly it will enhance your productivity significantly by allowing faster operational movements, quicker search and retrieval, data manipulation, and powerful file and string operations.

Our goal is to optimize these tools such that you reap the efficiency gains every day, compounding into years of better productivity. This creates more time for you to accomplish what really matters in your life, whether that is time for the family, your own business, or promotions at work.

This article will cover the setup of your terminal, it’s appearance, and some useful shortcuts. Next article we will move onto your shell, arguably the most important tool a software developer uses outside of their IDE. It is your entry point and main interface to your PC and must be fully operational with every tool necessary for the job. The Terminal is your entry point to using the shell and the CLI and needs to be setup correctly.

Terminal Choice

Your terminal is the portal to the command line interface where you will primarily use your chosen shell to interact with the operating system. It handles text I/O into the shell, control keys, renders text back to you, supports multiple tabs and profiles, keeps you aware of the current process, and much more. Choosing a terminal is like choosing your lab or workshop for the day, each comes with their differences and strengths depending on the workload you wish to attempt.

On Mac the default Terminal is good for basic use cases. It support profiles, color schemes, fonts, and handles keyboard input well. However we can do even more with a replacement terminal. I use ITerm2 and that’s what I will cover in the guide but keep an eye out for cross app features to utilize. It also supports tmux if that matters to you for use with SSH sessions. You can see some of the killer features here. If you are a non mac user you should try Alacritty, and on Windows Microsoft’s Terminal is an excellent modern tool and killed ConEmu for me.

To start with ITerm2, lets take a look at what I have as a frame of reference.

ITerm supports multiple tabs in a window, new tab with same profile (⌘+ d), new terminal window creation (⌘+ n), along with tab swap (⌘ + arrow key). I can also split into two windows on the fly via drag and drop or with shortcuts. You can also use ⌘ + a Number, where the number corresponds to the tab. If I hit CTRL + ~ I get a quake style dropdown terminal no matter the context.

This is great for when I need to log back into AWS SSO quickly, or run a quick CLI command and then escape back out to my main workload. Often I have terminals working on a specific context and this hot terminal helps not pollute my working terminals such as SSH sessions, git operations, and OS management. This dropdown terminal also supports tabs, so if you want some longer running processes like a system resource monitor like asitop you can keep it running in there. Since you can split panes vertically and horizontally you have a lot of information density using tabs and split panes.

Let’s rapid fire through some config options I like to build a max aesthetic terminal. Remember your workspace should bring you joy and make you happy, so customize away.

Read more

AI is an efficiency multiplier for getting work done. If you are unfamiliar with a topic it can fill you in on the known unknowns and let you discover what you don’t even know. If you do know about a topic then it can extend and enhance your train of thought, offer counter arguments, and predict the work your future work. On any range of the spectrum it is a catalyst for knowledge workers especially when it comes to coders.

In our previous Local AI article I showed how easy it is to run Ollama and get up and running within minutes with Large Language Models. Now we are going to harness those models to enhance our ability to code locally. By running the models ourself we can ensure that none of our data and code leaves the network. We can use GPT like chat interfaces with sensitive data such as passwords, internal resource names, and not leak out implementation design out to the rest of the world. No longer do we have to self censor and hand fix data before we send it off to an untrusted backend. We can keep our data out of the hands of OpenAI and other companies who might not have the best intentions and privacy policies, or might train their AI on our work. We can preserve our privacy.

For this to work we are going to use two different models so lets pull them before we get started. Keep in mind llama3 will be semi-broken in Continue until we apply a bug fix later on in this article.

ollama pull llama3
ollama pull starcoder:3b

Using VS Code with Local AI

Within your VS Code we are going to install the Open Source extension Continue. I have been using Continue recently on a small python project and it has helped me get up to speed much faster as I’m not a regular python dev. Please don’t take the python code seriously, it’s pre-pre-alpha. Also note that Continue works with Jetbrains products too, so follow that setup if you don’t want to miss out in your favorite IDE.

Continue as an extension adds inline suggestions with tab completion, a chat interface with context, and allows you to use remote AI, such as ChatGPT or Claude or more importantly local AI that we run.

Feature Demo

As far as using the extension I used the chat interface to help plan out the structure of the project, for library suggestions, and also to apply change it suggest directly into my code. Often the hardest part of a project for me is just starting and getting over decision overload. By letting the AI make some initial decisions I can worry more about implementation than getting bogged down on starter code boiler plate. One of the killer features is that it indexes your entire codebase for context, and you can also feed it specific lines of code and ask questions on it, and apply those changes inline. See a small demo below where I ask about a specific class and what it does.

I can also ask it about specific functions or ask more general questions with @ Codebase tag. If the chat interface notices any code that can be created it will allow me to copy it, apply it, or ignore it. When applied it is as a diff where I can accept or reject the suggestion. You can see below as I asked AI to generate some code for me. It’s not perfect of course as I had to make some indentation adjustments, but overall that was much quicker than me writing the whole thing out. It’s a pretty contrived example for showing everyone, but other times I have found this useful just as part of my workflow without thinking about it.

Let’s reflect that this was all generated via my nvidia 3090 graphics card running an 8 billion parameter model from Facebook. There are many better models that can help you but this keeps us private and secure from prying eyes and we can always run stronger models.

Additionally, the inline code completion is also powerful from Starcoder2. I had to write a 3 branch if/else statement processing command line input of single file path, multiple file paths, and a directory of files. The inline suggestions from starcoder2:7b kept nailing every suggestion as I kept updating the next line to follow the flow of the program. Of course this code could be refactored better to have less duplication but progressive iteration is how most great software was made, 1 step at a time here.

So lets actually walkthrough how to configure this locally for you.

Configuration

After you have Continue installed into VS Code it will ask you setup an AI backend. If you wish to go any online provider such as ChatGPT or Claude, then follow the instructions for that and you are done. If you are hosting Ollama on the same computer as VS Code, follow the flow for Ollama and follow the llama3 fix later. However for me I am going to use my server on my local network with Ollama, which requires a little more work. I will cover serving Ollama on network further down, but for now just follow the Ollama flow also. Open the extension on the right side panel where Continue suggested you put it. Then click on the settings icon in the bottom right to open up the JSON config file. We can now configure any additional AIs that we need.

We are going to add our own Ollama based AIs here. Since we are using llama3 we need a specific entry as we have to fix a bug in it to get it fully working. In the config.json go to “models” element and add a new entry like below. If you wish to keep other AIs, just append this new item in list. See below.

Read more

If you are not using software to make your life easier then you are wrong. The days of light, minimal computer setups are over. We have a rich ecosystem of software now that can enhance your productivity across multiple devices and operating systems, from browsers, to code, to security, to SaaS, and to digital storage. In this article I will go over some of my favorite browsers and browser extensions that I use to be productive daily so that you can be setup correctly to succeed even more. The faster, more productive you are on your computer directly correlates to less time at work and more time on WiFi money.

The first thing I do when setting up any computer is to get my Browser, Adblock, and Passwords in order. Once I do that I can operate at an efficient no matter what device I’m working on. This will let you browse the internet without annoyances and gives you the access you need immediately. These are important to get correct right from the start as it is the base layer of computer and knowledge work. If you’re still using browser based password managers and subjecting yourself to Ads you’re not gonna make it. An old product manager of mine never used an ad blocker and every time they shared their screen it was embarrassing seeing the targeted ads he was sent. No one want’s to see your underwear ads, so let build up your browsing levels.

Let’s get setup.

Browser Philosophy

The application you will spent the most amount of time in is the internet browser. Therefore it makes sense to spend time optimizing it. With the right choice of browsers, some extensions, and proper ad blocking you can speed up your daily browsing and reduce your annoyance with ads while preserving your privacy and security.

The standard recommendation for a web browser from me is Brave Browser. It takes all the good parts of Chrome based browsers, the speed and compatibility, and combines it with a privacy focused organization supporting it. Most importantly it isn’t run by Google, who will do anything and everything they can to get their hands on your data (see their 5 Billion dollar lawsuit loss they on Incognito mode). It’s convenient in a way that Google, a company that makes it money via internet advertising, also shepherds the means to which you can access the internet. Talk about double dipping. This is why I never recommend using Chrome browsers, you can’t trust your privacy with Google.

To make the simple point why Brave is better and more private than Chrome, Brave ships with a built in ad blocker. Chrome in the meantime is going to start limiting adblockers to stop disrupting their business. Advertisements annoy me and we as people should do everything we can to remove annoyances in life.

Brave supports every major OS and mobile devices, so you can ensure a consistent experience between all devices. I’ve used it on my phone, personal Mac and Windows machines, and my work machines for close to 7 years now. Since Brave works on so many platforms you also get their adblock experience on those platforms easily. It will blocks ad that are often native to the platform you are on, such as YouTube, and can also disable tracking methods from Social media sites if you don’t use them.

Some additional features Brave ships with:

• Vertical Tabs!

• Background audio play on Mobile via Playlist

• Auto Speed Reader mode for articles

• Built in VPN (use your own though) and Tor

• IPFS support

• Built in Crypto Wallet (use your own though)

• Chrome extension compatibility

• Disable AMP based pages

• Ethereum Name Service support

• Customizable privacy features

• Speed Reader Mode

• Popup Blocker

There’s plenty more but I don’t want to be an advertiser for Brave, just know I’ve been a really happy customer with them. However Brave has set some defaults that personally I like to change to get a smoother experience. For example, Brave has a “rewards” program called BAT that replaces 3rd party Ads with their own, more privacy focused Ads and also pays you for it. You can disable this completely like I do and use the AdBlocker to its full extent.

To start with my personal config settings, go into the Settings icon in the top right menu icon, then follow below.

• Appearance Tab

  • Enable Vertical Tabs

  • Disable Brave News, Brave Rewards, Brave Wallet, VPN Button

  • Always show bookmarks

    • Save your most frequent sites into bookmark bar for faster access

  • Enable Wide Address Bar

  • Enable Full URLs (this makes you more secure)

• Shields Tab

  • Trackers & ads blocking → Aggressive

  • Block Cookies → Only cross-site

  • Enable Auto Redirect -AMP pages, tracking urls

  • You can also disable specific social media embeddings on sites

• Privacy and Security

  • Disable Allow p3a

  • Disable send daily usage to Brace

  • Disable Auto sending of Diagnostic reports

  • Block Third Party Cookies

  • Enable “Do Not Track”

  • Upgrade connections to HTTPS → Strict

• Web3

  • Don’t use their wallet! Always use hardware wallet

  • Enable IPFS if you wish (this can track your IP if using public nodes)

  • Enable ENS domains if you wish

• Leo AI

  • Disable

  • Disable Show Leo in the context menu on websites (this seems to be brand new and also auto enabled)

• Sync

  • Every time I used Sync it failed for me, so don’t use. We will use a different service for bookmark syncing

• Search Engine

  • Brave search isn’t great, especially for coding. Currently using Google, Bing, ChatGPT, and Perplexity.

  • Disable improve search suggestions

• Extensions

  • Disable all Google Things, Hangouts

  • Enable Web Torrent if you want that

  • Disable WideVine, a closed course extension by Google for Video DRM

    • We will sacrifice another browser to only use WideVine for video watching

• System

  • Enable Memory Saver and Energy Saver

This gets you a reasonably private and secure Browser while not breaking too many websites. By no means will you be the Jason Bourne of browser tracking evasion, but it’s good enough for regular daily use. Counterintuitively the more aggressive you try to preserve privacy in the settings it actually makes it easier to fingerprint (track) you, so try to not go overboard. Check Am I Unique and adjust as needed to blend in with the crowd. Privacy is a tradeoff with being inconvenienced, so I try to strike a middle ground as much as possible. If you have an immense need for more privacy check out Privacy Tools for more inspiration.

A quick few notes on some useful things I do in the browser for additional productivity.

Read more

Often you will be away from home but would like to appear as on your home network or access home LAN resources. For this we can use a WireGuard setup which handles the security, even when on untrusted networks. Two routers can handle this for your network setup.

First, a home router that supports Adguard, a WireGuard server, and all running OpenWRT. I bought the GL.iNet Flint 2 router for home: https://www.gl-inet.com/products/gl-mt6000/

Next, a portable router that has a config and cert to your home WireGuard server. This allows your device you want to connect no visibility over the private connections you are about to make. I used the Beryl AX for a portable router: https://www.gl-inet.com/products/gl-mt3000/

Assuming you have a static IP (if not, enable DDNS and use those configs), in the home router create a WireGuard server and generate your WireGuard client config files. Create one for each device, including your portable router, and save on the device that needs them. On Mobile download the WireGuard client and on PC save the configs and upload them to the portable router once connected. Then enable the client and you'll be on your home router! In WireGuard server you can enable things like LAN access to get access to your local Samba Servers, DLNA servers, Linux servers, and more if you wish. Just ensure you keep your access keys secure or you'll have a breach. You can see more step by step instructions here.

Now on public wifi or in a hotel room you can securely access your home network, servers, files, and more. This is great when on untrusted wifi and even works if you need mobile cell phone access to your home network.

Was able to test while out of the country and confirmed no issue and good speed to my home internet. I used this to work remote out of the country with no issue. Since the router contains the WireGuard info, my work PC had no idea that it was on a different network from a WiFi point of view (there are other tracking means, so don't think this is 100% effective). Great way to get around networking and VPN restrictions on your devices as the portable router handles all the connections, with the bonus of any other WiFi devices piggybacking on the portable router also.

Subscribe now

This free article was cross posted on X for an engagement experiment.

The biggest issue with AI tools such as ChatGPT are the lack of guarantees around data privacy. You have no say in whether AI will be trained on your prompts and inputs unless you are a higher end customer who pays for the benefit. OpenAI has shown to be a questionable steward for the AI movement as a “nonprofit” company and we should always question the motives of Big Tech with their censorship of models. Thankfully open source LLMs have improved significantly due to efforts of many contributors on the internet. One such model that can be used for coding specific work is OpenCodeInterpreter which has some benchmarks that have it competing with ChatGPT4.0 in coding scenarios. You can see more info on their site here.

For context my hardware is an M3 Pro MacBook with 18GB unified RAM. You’ll need to adjust what size models you use depending on your hardware as there are smaller and bigger models to choose from and your RAM will influence that.

We are going to use Ollama, which helps download and run models locally and offers additional functionality such as API endpoints, code libraries, base prompt retraining, and OpenAI compatibility. The software is reminiscent of using Docker in many ways as you can easily download multiple models and run them at will all with a few simple commands.

Executive Summary

1. Download ollama

2. In terminal run: ollama run pxlksr/opencodeinterpreter-ds:6.7b-Q4_K_M

3. You now have a local, private chatbot in the terminal

4. See integrations you can now use to get a native chat UI and more

Demo and Install

To run the models locally you will need to install Ollama which you can find a download link here: https://ollama.com/. I’m using this on Mac and ran into no issues in the process, but if you’re on Windows just note the support is recent for it and still in preview.

After installation you can verify it worked by running ollama -v and confirm the application can be found.

Now you can execute ollama run llama2 in the terminal and you will be kicked into the chat prompt within the terminal. I asked it to generate all prime numbers up to 100 in Go and it successfully output the program, which I ran locally in my terminal with no issue. You can see the performance below in real time.

Here is the code that was generated:

package main

import "fmt"

func main() {
    for i := 2; i < 100; i++ {
        if !isPrime(i) {
            continue
        }
        fmt.Println(i)
    }
}

func isPrime(n int) bool {
    if n < 2 {
        return false
    }
    for i := 2; i * i <= n; i++ {
        if n % i == 0 {
            return false
        }
    }
    return true
}

One thing to emphasize is that this was all done locally! No external API calls, no privacy breaches, no personal data leaks, and can run with censorship free models all done on the hardware you own with open source code and models!

While the terminal prompt is useful, we also have access to an API endpoint too.

curl http://localhost:11434/api/generate -d '{
  "model": "llama2",
  "prompt": "Write me code for the classic fizz buzz problem",
  "stream": false
}'

If we pipe the response to jq we get:

{
  "model": "llama2",
  "created_at": "2024-04-01T00:48:41.657866Z",
  "response": "Of course! Here is some sample Python code that prints out the numbers from 1 to 100, replacing multiples of 3 with \"Fizz\" and multiples of 5 with \"Buzz\":\n```\nfor num in range(1, 101):\n    if num % 3 == 0:\n        print(\"Fizz\")\n    elif num % 5 == 0:\n        print(\"Buzz\")\n    else:\n        print(num)\n```\nLet me know if you have any questions or need further clarification!",
  "done": true,
  "context": [...],
  "total_duration": 4301712292,
  "load_duration": 2555167,
  "prompt_eval_count": 16,
  "prompt_eval_duration": 268586000,
  "eval_count": 124,
  "eval_duration": 4029886000
}

A better look at the code:

for num in range(1, 101):
    if num % 3 == 0:     
        print(\"Fizz\")
    elif num % 5 == 0:       
        print(\"Buzz\")  
    else:   # some versions of fizz buzz sup
        print(num)

You can see more of the API capabilities here for integration here. When using the API use the keep_alive parameter to avoid the model shutting down between queries since by default it is only 5 minutes. Querying the model doesn’t seem to reuse the current model in a terminal session even if its the same model, so you will see longer response times up to 15 seconds due to your CPU and RAM being taken up already. If you kill the terminal model you should have faster API responses, though I have seen it still take around 10 seconds, but also be as short as 2 seconds. I’m not sure if this is an API only quirk as using the terminal interface has always been very fast for me.

They also have a python and javascript library for non http based IPC. Ollama also has partial support for OpenAI’s API format, meaning you can sub your local model’s endpoint for any OpenAI based integration.

Using the Coding Models

Now that we have a model running we can switch to more targeted and trained models for coding.

Read more

Physical Management

If you’ve ever been sick as an adult you know you’ve said the following, ”I would do anything to be healthy again”. Inside this statement rings the true inner feelings of what a gift it is to be fully healthy and able bodied person. But why do we tolerate good enough healthiness, and not perfect health? I’m absolutely not innocent in this area and I know other people are not either. Even recovering from sickness at 80% health, you are not at the same capabilities you have at full health!

In fact I’d argue the average person isn’t even 80% healthy on average. With the general population being overweight and more office workers constantly inside their house all day it’s not a surprise people are neglecting their physical wellness. I didn’t take it seriously either in my early 20s and felt like garbage every day. Overweight, not attractive, drinking often, no dating game, even a slight limp while walking due to tight hips and back, just aimlessly going through life. But once I discovered there is so much more to life I got serious and am now healthier in my late 20s than as a younger 20 year old! It’s amazing how the consistent application of apathy towards your health can hurt you even when you are relatively young. Imagine if you were consistant in the other direction how healthy you would be!

So what did I do to turn my physical health around? I tried intermittent fasting and cardio and it worked to get the weight off, but I was still “skinny fat”. It was a half measure. I got word back from my doctor that my blood test results were not great, elevated liver enzymes, non optimal cholesterol, and high triglycerides. I didn’t do much after, but I did get lucky from following (WSP) and thankfully ‘s publication came around and changed everything for me.

Strong As An Ox

3 Day A Week Upper/Lower Split By BowTiedOx

Introduction Welcome and hello! What I have put together is a simple 3 Day a Week Upper/Lower Split made for those that are familiar with lifting, and looking to maximize the most muscle growth with the least amount of time in the gym. This program is simple, efficient, and will absolutely pack on size. This is perfect for the busy professional, student…

Read more

5 years ago · 175 likes · 73 comments · BowTiedOx

I decided to embark on his 3 day a week full body workout plan and commit myself to lifting weights and the rewards have been continuous to this day. I studied and implemented to the program, ate better, and tried more walking and cardio. I turned in the cleanest bill of health from my doctor the next time I saw him a year later and felt more alive than I’ve ever felt. If I had to point out the single most important moment in my life the last 5 years it was that first time in the Gym trying to figure out all the lifts I needed to do from Ox’s program. If you don’t have that zeal for life everyday something is almost certainly wrong and you need to make major changes.

When I say this changed everything, it really did. I had a moment about 6+ months after lifting when I visibly saw some significant muscle growth and did a double take in the mirror and knew I was on the right path. I kept at the program and everything else in my life suddenly aligned with purpose. My confidence and execution level in everything exploded and suddenly me, a quiet introvert, was growing more strong willed and charismatic than ever. I’m not going to go on about my personal story but I want to drill the point home that being healthy is almost a drug in itself and it creates strength and confidence everywhere else in your life. You will see exceptional gains in life going this route.

The direct rewards are also tangible toward my career, with programmer specific issues like “Imposter Syndrome” going away completely, and multiple raises and promotions happening within this period. Public speaking became much easier and I knew I could accomplish whatever was thrown at me. It gave me the confidence to go out to the marketplace and get an even better job with superior pay all while working remote. I also non-coincidently earned my first wifi money during this period. I believe moments of self actualization like this combo well with other endeavors. Don’t be surprised when you’re in the thick of the lifting program you want to make more money outside work.

Not only do you get the physical benefits of strength and longer lifespan, but you gain the ability of immense confidence in your skill set and know you can go toe to toe with anyone out there. I can’t imagine how life would be if I didn’t do this, but it would be too depressing to even try to imagine.

Physical Optimization

Now that we’ve covered the idea of actually being physically fit and in shape, we can cover more specific optimization for the software worker.

Read more