I bet you are reading this on your browser. Are you certified to use that thing? Where did you get your license? Do you know how to operate it? No seriously? Do you? DO YOU???

The wonderful world of browsers​

Okay let’s be slightly more serious, web browsers are probably one of the single most important applications on a device. Browsers are also one of the most important pieces of software in the modern world. They connect the people, power the businesses, drive economies, interface with systems, and connect individuals. They are the pathway to many abilities some consider to be unnatural to many things. Anyone who has used a computer, and interacts with the internet has used one. It's almost guaranteed you are using one as you read this right now. Well maybe you are cool and subscribed to this blog using an RSS feed reader like inoreader. No, I'm not paid to say that... Why do you keep asking?

Anyways, their designs have been well tested, iterated upon, and developed by some of the biggest tech companies on Earth. There have been massive successes, massive failures, huge security issues, long and drawn out rises, and dramatic falls from grace. If web browsers were a TV show they'd be chugging into beyond their 20th season, and it's only getting more popular. They are a staple of the modern world. But like any show that sees their double digit season, let alone a multi-decade show, similar "themes" keep popping up again and again. Why change what works?

Today, you can pick up almost any browser and find yourself at home with similar features, where the general design and features have been the same decades ago. But that doesn't mean all are the same, or try something dramatically different. This also doesn't mean you are using them to their full potential. In fact, it's fairly common to see someone whose browser looks like the image at the top of this post.

This post is all about web browsers, specifically how to use them to their full potential. I'll go into some historical features as a background, core features basically all browsers have, then jump into focusing on just Chrome. Why only Chrome and not other browsers? Well that's what you dear humble browser reader get to learn about.

So sit back, don't touch that tab bar and let's dive into the wonderful world of browsers, and how to make the most of them!

Humble beginnings​

It’s hard to talk about web browsers without at least touching on the “birth of the web”.

The dawn of a new age, a tabbed one​

The turn of the century saw multiple browsers of the time start adding one of the single most critical features that all browsers utilize, which is tabs. Tabs are essentially separate instances of a browser window that allow the user to “switch” between them, allowing them to effectively multi-task. Tabs are available in all sorts of systems that allow users to do multiple things at one time and are an effective user experience pattern.

No other feature exemplifies the power of the web more than browser tabs. It’s fairly common to find yourself “fighting tabs”, if you decide to fight them at all. The web just has so much to keep track of, read, find, search and interact with. It’s literally infinite! But that also means your small little tab bar, and your poor RAM sticks. (yo RAM is expensive nowadays, protect that stuff, if anything do it for the RAM!)

Tabs made sense at the time, and still make sense today, but due to the extensive nature of the web, expecting just a simple humble tab bar to “capture” everything you’d want, or possibly want to keep track of is where most users go wrong. But before we continue into the actual tips, let’s continue our trip down memory lane. As tabs by themselves became a core feature of browsers (and other applications), they themselves don’t change much, and most users don’t change how they utilize browsers beyond tabs either. Before we dive into the other features, let’s continue our journey to the present day with the expansion of the web away from just serving websites, but instead turning into a platform for serving everything and anything.

Champions rise and fall​

With all browsers having tabs, users turned to what's in those tabs. What’s in those tabs has to work, and what browser do you use when you want stuff to just work? Of course you use chromium Internet Explorer! Well at least you would if the era were the 2010s.

With the rise of websites such as Facebook, Google, and Amazon. More people used the web for the first time and actually did something. Then came back, then wanted to do more. Tabs (and bookmarks) were around this time to help satisfy the world's budding navigation trends, while listening to nice dial-up noises before checking your AOL account.

Good times, simpler times. But I’m sure some true power users were already starting to see issues with being limited to just tabs and bookmarks. But I wasn’t old enough to know that, so I’ll just gloss over this fact and assume no one was running 100 tabs back then, I’m sure I’m wrong but for the sake of the “story time” aspect of this, we will just run with it.

Around this purposefully vague period of time, the main champions of the web were Microsoft’s Internet Explorer, and Mozilla's Firefox, but a new challenger approaches in the form of Google’s Chrome, which is currently the most popular browser out there. Even if you don’t use Chrome you probably use a version built on top of Chromium, which is the open source project underpinning Chrome, so think Chrome but without Google’s stuff.

Even Microsoft’s champion, Internet Explorer, eventually gave way to Edge, but Edge as it traditionally was built, ended up being a failure. Microsoft eventually waved the white flag and moved to a Chromium based version of Edge that is still around today.

Cloud, the modern era and consolidation of power​

The 2010s saw one major shift that cascaded everywhere in the web, including the browser. It was the emergence of what is called “the cloud”. The main incentive of the cloud is to power website infrastructure at a cost. Before this, any company who wanted to run their own website largely ran their own hardware, this would be their own physical server racks running somewhere in your own office. With the advent of the cloud, anyone can just pay another company with their own dedicated hardware a fee to utilize their resources, today many companies go this route as it is flexible and generally cheaper.

Now you might be asking how does the cloud relate to browsers? The main reason I’ll provide here, is that this allowed many more companies to build out their website infrastructure, and look for people to pay to serve them. This is when the rise of “big tech” started to gain traction in the web infrastructure space, suddenly a lot of companies and consumers wanted to build “on the web”, which brings us back to the basic question. How do people get there?

As you might have already guessed, it's web browsers! Google specifically built out Chromium to help get customers to the web. For them, this meant getting ad money for Google searches and later cloud money through businesses running on their infrastructure, so indirectly funding a “better browser” was just another way to build out their other businesses, and investing into their browser in a way to make the web more enjoyable and capable fed into their other main money makers.

I primarily bring all this up as to the main reason why I’m focusing specifically on Chrome, as there’s a ton of options out there (see the bottom of this post for a list of ones I know about), but focusing on the current most popular browser seems like a good bet.

Cool but wait, when are you going to talk about how to use the browser exactly?​

Okay okay! Now that we’ve gotten from the dawn of the web, to the cloud, with Google’s web/browsers, and some initial mentions of how to use web browsers is over. Let’s actually jump into using the darn thing. With this history we can also see how some companies make money based on your experience using the web, with the browser just being the initial interface.

Because that usability and raw experience is a core functionality and difference maker on many browsers, it’s also why Google funds Chromium’s development. Ultimately they win at the end of the day if you are using a web browser, even if it doesn’t have Google’s direct integration.

Okay let's get to the “learn how to use” portion finally!

Tabs​

Tabs are the main productivity feature most users know, think about and use. Tabs are at their bare minimum a way to do multiple things in a single browser window. They are also easily the most abused feature. Many users end up with many tabs open to the point they can’t see anything besides the favicon. Most browsers allow users to move a tab out of their original window and into a new window, which can help with multiple monitors.

For many people, they are the “first option” and “last option” when using their browser extensively. It's possible even having this exact webpage open among 100+ other tabs! Or if you are on the other side of the spectrum, and don't use them you should! It allows you to keep multiple webpages opened at the same time, and allow you to do multiple things at the same time.

I won't go into it more as I assume most users already know how to use this feature. So lets get into the more helpful/nuanced stuff.

Before we do though, here are some rapid fire keyboard shortcuts:

• New Tab: ctrl + t (Win/Linux) / cmd + t (Mac)
• Close Tab: ctrl + w (Win/Linux) / cmd + w (Mac)
• Reopen Closed Tab: ctrl + shift + t (Win/Linux) / cmd + shift + t (Mac)
• Switch Tabs: ctrl + tab (next) or ctrl + shift + tab (previous)
• Jump to URL bar: ctrl + l (Win/Linux) / cmd + l (Mac)

Pinning​

In Chrome and many other browsers, pinning is a feature where if you right-click or two-finger click on a Mac, a tab you can select “pin” that tab. This pushes the tab all the way to the left of the tab and condenses it down to just its favicon.

This feature allows you to keep tabs in a specific order, and more accessible as they are essentially in their own group. I use these for a few sites I always keep open no matter what. Critically using ctrl + number-key (or cmd + number-key on Mac) allows you to jump to your tabs, pinned or not. But having the same tabs setup allows easy access to the same sites every time via these keyboard shortcuts.

Split tab​

Split tab is a new feature available in Google Chrome, which allows you to essentially render a side by side view “within the same tab”. This can be helpful if you don't want to manage multiple Chrome windows while also being able to work in multiple tabs that you see at the same time side by side.

As before you can right-click or two finger click a tab to “add tab to new split view”, or you can select multiple tabs holding down ctrl (cmd on Mac), select your two tabs, then “add tab to new split view” and this should connect the tabs to a new split view.

This feature in my opinion is useful, but somewhat awkward, as the tabs share the URL bar so knowing which one you are actually on can get a little confusing at times, as the usability distinction between which tab is under focus and which isn’t isn’t clearly defined a majority of the time.

That said, let's continue as tabs are great, but just being able to pin or split them doesn’t actually help a majority of users who have 100+ tabs open and no idea of what's in them!

Bookmark organization, and the "reading list"​

Bookmarks are old browser features that are underutilized. They are very powerful, but I think they are not as visible as tabs, so most users don’t rely on them. They cover one of the main use cases most people have for opening multiple tabs, which is “not losing information”.

Bookmarks are like what their name intends, a way to save places on the internet to go back to them later. Explaining that isn’t what this section will be about, instead I’ll point out a few reasons why you’d want to save your huge list of tabs as bookmarks instead and save your poor web browser from keeping them open continually.

Go into your tab and click on the “star” icon in your URL bar, or press ctrl + d (Windows/Linux) or cmd + d (Mac). This will bookmark your tab. However that isn’t how to use bookmarks, instead organize your bookmarks into folders and utilize those folders as a way to find what you need later. If you leverage this feature enough, and combine it with other features such as “bookmark search” you can build your own little knowledge base that is searchable and organized.

To manage them all at once, you can open the Bookmark Manager with ctrl + shift + o (Windows/Linux) or cmd + option + b (Mac).

But it all starts with saving your bookmarks, naming them sensibly and taking time to organize them in some sensible structure. It's similar to files in your filesystem, doing some spring cleaning every now and then can go a long way.

Bookmark search​

Google Chrome, and many other browsers, allow you to easily search your bookmarks. In Chrome you can just type @bookmarks then hit space and search for what you want, and you will search against all the bookmarks. You can then select individual bookmarks or just hit enter and go into Chrome’s bookmark manager, which is available at chrome://bookmarks (other internal pages will be gone over later)

This search feature is available in that internal page, and the bookmarks sidebar.

Bookmarks bar and bookmark sidebar​

You can also use the bookmarks bar or sidebar to see and organize your top-level bookmarks that you always want quick access to, or see a list of searchable and filterable bookmarks alongside whatever you are working on. A quick way to toggle the bookmarks bar is ctrl + shift + b (Windows/Linux) or cmd + shift + b (Mac). This can be used along with the search and folders to effectively have a “file system” of bookmarks on the side of your browser. But as I said earlier, this requires your own effort to maintain and work to build your own setup.

Tab groups​

Tab groups are one of the “newer” features that has come around in the last few years that adds a level of organization to tabs more directly than saving things into a bookmarks folder. Tab groups allow you to put tabs into a colored “group”. In Chrome this can be done by right clicking on a given tab and clicking “add tab to group”.

This pattern allows you to “collapse” tabs and organize them all in your tab bar. Many browsers have a secondary “store” of these tabs so you can close the tab group and open them later. With Chrome this syncs across devices, so you can save your tab group on one machine and open/reference them easily in another.

Tab Groups should be the first thing you try to utilize, as it builds on most users' common workflow of just having a lot of tabs open. They don’t solve the problem directly, you can still have a lot of tabs, but you get at least 1 level of organization/abstraction and the ability to collapse them.

Mixing tab groups and bookmarks you can easily turn bookmarks into tab groups and vice versa for a more “solid” way to save tab groups over time, while also giving you multiple levels of control and ability to search/manage groups and bookmarks.

Pro-tip: Name your tab group with an emoji and when you collapse it, it turns into the width of a single tab! On windows this can be done by right clicking on a tab-group, then in the tab group name field, right click again and pick “Emoji” then search/pick a sensible emoji to represent your tab group.

Tab Search​

Let's say you have read all of the above advice, learned some high level web browser information, but then still just spam tons of tabs. Well this is the one other feature you should use way more. It's searching tabs.

Chrome provides a “tab search” button near the top, or you can hit the keyboard shortcut for ctrl + shift + a (or cmd + shift + a on Mac). If you hit the button it will also show tabs from other devices if you have sync enabled. Or you can search in the URL bar by typing @tabs then hitting space.

As long as you know the name of your tab you want, you can use this to find it!
Most other browsers have a variant of this feature, which again can be a huge help as long as you know the name of the tab you are searching for.

Pro-tip: if you skipped the section of searching bookmarks, check that section out, it uses the same “url search” mechanic!

The new UI pattern of vertical tabs​

Vertical tabs are a newer feature that leverages the fact most people’s windows have gotten “wider” over the years. Because of that there’s more horizontal space than vertical space, so to make use of that you can move your tabs to the left side of the screen rather than the top.

This has one key side-effect, that combined with tab groups, allows you to see most of your tabs titles, and group them in a nested tree. You could use short names for tabs with horizontal tabs, but with vertical tabs you could name them more verbosely.

The same “tricks” apply here, allowing you to search tabs and groups but with the ability to see more of the title more easily.

X-factor features​

Below are some “x factor” features, features that you could never use, but if you do they could be game changers depending on what you are doing. So these are provided for those looking to “up their game” either way. Since these are largely situational, I’ll leave an extra note about why you’d want to use these.

Installing web pages as PWAs, or as "apps"​

The why
Use PWAs, or “Progressive Web Apps”, if you want better integration into your desktop

PWAs is a browser feature that some websites support. There are websites that act more like mobile or desktop apps, and have extended features to fill that niche. The technology is several years old, but only some websites actually leverage it. Examples would be:

• Youtube
• X/Twitter
• Spotify

You usually see this as an “install” icon in the URL bar on chrome. Once you install it, it will appear in your taskbar and is searchable like any desktop app. Critically this completely offloads the app from your browser, so it opens as its own desktop app. This also allows you to “right-click” on the app icon and immediately jump to specific actions within the app directly from the icon. This can help some true power users access common functionality quickly and easily.

This can be very helpful if you use some apps and want your operating system to manage their windows instead of your browser. If you want to remove them, you will uninstall them like any other app and go back toward using your browser to access the site/app.

For websites that do not offer PWA support, you can get a similar experience by installing the page as a “shortcut”, which in Chrome is available from “cast, save and share” then picking the “create shortcut” button. This will work similar to a PWA, in the sense your operating system will then be able to manage and find the webpage, but it won’t provide as many features as a PWA as it's just a shortcut.

Site search, make specific site searches easily accessible​

“Site search” is a way to isolate individual sites that have a “search” option in Google Chrome. This way you can enter in a prefix, for example `@github` then hit space, then search directly in GitHub without leaving your URL bar!

Continuing the same example, for GitHub, you can search in GitHub via its search bar. Once you enter a query and hit search, you can see how the query is passed in so the url looks something like this: https://github.com/search?q=bradtaniguchi. The q query parameter is what you need to remember, and utilize in the next step.

Next go into your browser settings and go to “search engine”, then click on “Manage search engines and site search”. On this page you can add a site search option, name it “GitHub” or something similar for its prefix. Then provide the following as the value: https://github.com/search?q=%s. Now you can use your prefix and search GitHub much faster!

Expand this for any site you like to use, and you can jump through to find stuff on that particular site more or less from anywhere.

Bookmarks as links is only the beginning, code your own "button"​

I already went over bookmarks, but this section is on a very specific (and coder oriented) use case where you can save JavaScript as a bookmark, then upon clicking the bookmark, it executes the code onto the current page!

This can be useful if you have a small snippet you like to use, or want to literally “save” a script to execute to “hack” a given page at any given time. Of course this isn’t real hacking, as you are only executing front-end JavaScript code. There are also other ways to do this more elegantly, such as from the dev tools, or having extensions which are designed to inject/run arbitrary JS as needed. But this is a neat little feature that could be useful and played around with.

Performance and Memory Saver​

Lastly, let's say you don’t like to use tab groups or bookmarks and you still keep hundreds of tabs open. Changing your browser’s performance settings can help keep things running smooth, or at least reclaim some memory for tabs you don’t go back to. This does have the side effect of making going back to idle tabs mean they refresh (which you might not want to happen) but concessions must be made if you want to free up some memory.

To utilize Chrome memory saver, go to the “three dot menu”, then to settings. Then performance, then select the type of performance you want to leverage.

What about extensions?​

I purposefully skipped over and ignored browser extensions, or even other browsers. The main reason for this is because there’s a lot out there that could be useful, and I can’t go over all of them, nor could I do it with any justice as I don’t actually use any productivity extensions that change the behavior of the browser. I use what it gives, with the single exception of turning on some flags here and there.

For example, vertical tabs aren’t public yet, but are available behind a flag in Chrome Beta. I usually use Chrome Beta anyways, so I flipped the flag and have been working with vertical tabs for a while to see how it is. It takes some getting used to, but so far I like it.

Conclusion​

Hopefully some of the above is helpful, and insightful. I might write another post on how to utilize browsers, maybe a more “demo oriented” one, but this post is already one of the longest I’ve written, and I plan to write. I wanted to give it my best!

One of the next things I’ll be working on is allowing for some way to provide feedback to these posts, without opening myself up to spam. But this is for another day, and something I’ve been working on behind the scenes.

The Question​

It's sometimes exhausting to be a developer.

I knew this going in and developed a few habits to keep me in the loop. This became more important once the rate of what I needed to know increased. Where today things are almost exhausting to keep up with.

I've been asked by a few people over the years the exact question of "How do you keep up with latest trends?". It's a simple question, but one where I try to give a nuanced, and "different" answer. Most people think of looking to social media, such as reddit, linkedin, instagram, and youtube. But I don't actually use these to keep track of the latest trends.

I use something more old school, I use RSS feeds and inoreader, which is an RSS feed aggregator.

So what's an RSS feed?​

Here's the copy paste description from Wikipedia

So essentially, an RSS feed is a way for you to subscribe to a source of content using a tool such as inoreader, which will keep track of new content.

My Workflow Philosophy​

In terms of workflow I keep to my guns and do not actually change my workflow very quickly or dramatically. I try to make the most out of the tools I'm currently using until something breaks, rather than trying to chase drastic changes. Because of this, I'm aware of trends but might not actually leverage them until I see more general traction and learn more about it. For example, leveraging AI has been something I've been using consistently but never full on the "hype train". This is yet another reason why I started this blog, it's to help me consolidate and explain these things in a structured format.

It's true that we live in the "information age", with more information than ever being able to be consumed any multitude of ways. Just like dieting, and watching what you eat, I believe in curating and managing what information I consume. Not only for keeping up with technology trends, but also to stay aware of the world, while avoiding the "traps" of attention that can be social media based sites and services.

Sources and Tools I Use​

• inoreader - My primary RSS feed reader
• YouTube - I do actually use youtube, but only as a rough guide. I rarely watch videos that are over 10 minutes, largely to get an idea before jumping in myself. I also only watch a handful of core channels, and avoid any number of common sources

Types of RSS Feeds​

Types of RSS feeds I look to leverage:

• Blog sites for known technology, such as the blogs for specific technologies such as React, or tooling like vite. These tools post news updates, which you can directly follow
• Individual publication (is it weird I follow myself lol?)
• I largely ignore medium or other social sites as "too spammy", you could follow medium authors or topics, but again it spits out too many articles.

The Skimming Strategy​

I skim most sections and rarely read individual articles, this gives a high level idea of what people are talking about, without actually participating in social media. There is no doom scrolling unless I deliberately set it up that way. I do miss out on a huge number of things, but by sheer consistency I will notice articles and topics that pop up more often than others. I also have a folder that I read every article in, so I cannot miss anything for these "favorites".

Read later, and inbox zero​

I have the inoreader extension for my browser, which allows me to add whatever site I find interesting to my "read later" list. This way regardless of where the content is I can "add it" into my inoreader feed as a "read later item". I'm a stickler for inbox zero, so I continually go through my read later list when I get a chance. I never actually get to inbox zero, but I do keep it manageable.

YouTube​

I watch YouTube mostly for entertainment, but in regards to development and learning I look out for either shorts on a given topic, or short-form content videos going over a given technology. These videos are more for me to understand what a given technology could provide to me, rather than for me to learn all aspects of it. I don't really watch long format content as it's too hard to pay attention, and I can just as easily read the docs as my own pace as needed. This is also where individual doc pages can be saved to my inoreader and be read when I get a chance.

The current channels I recommend for short format content:

• web dev simplified - main channel to learn about web dev stuff, very minimal fluff
• devopstoolbox - where I got "inspired" to improve my terminal setup
• fireship - especially their "in 100 seconds" series

Example RSS feeds​

Here's some example RSS feeds/sites I follow for web development:

• https://blog.github.com/ - GitHub's blog, where they post about product updates. I use a lot of github oriented products for my personal development workflow, so I like staying in the loop
• https://techcrunch.com/ - tech blog, great for high level topics. One of the "skimmers" I glance at along with other similar sites to get an idea of common trends at a glance
• https://www.freecodecamp.org/news/ - tech blog, great for in-depth guides. I find myself saving an article here or there to read up in depth later. Otherwise another site I skim through a majority of the time to get idea of trends.
• https://www.web3isgoinggreat.com/ - tech fail blog, I have a few "fun" sites I track, this is one that I paid more attention to with the whole "web3" trend. Stuff still comes up, and web3 is "still going great" (You will not hear me talk about web3 in this blog basically ever again)

Wrapping up​

Like most things, I think getting the most out of what you have is more important than trying to change more ways to do the same things. (hopefully that makes sense), I really only use 2 tools, but those two tools cover all gaps and bypass all the junk out there. I could be missing out and slow to adapt to trends, but I won't be unaware of them, and if they are that important and impactful I will eventually follow up on them as I see more of them through my RSS feed.

So yea, I like reading and keeping up with things my own way. I think I can write a bit more about this topic, specifically how I use inoreader, and a few other sources to fill my free time with something more positive rather than doom scrolling, but this broader topic will be for another time.

Until next time, keep learning, keep building, and keep asking questions!

PS Bonus points if you follow this site yourself! See the footer below for the RSS and ATOM feed. Most modern RSS feed aggregators can handle either.

Developer tooling that goes beyond the basics, and what I've used for over a decade. The tools I use aren't new, or super fancy or anything explicitly tied with AI. But I've found them very effective and use them on all my machines. Recently, I started re-building my dotfiles repo, and it made me realize that going over my current "terminal workflow" might be an interesting read, as its very unique to me. So lets hop in and see what tools I've been using to help me stay productive and look cool in the terminal hehe, but first lets jump back to my college days.

Origin story​

Back in 2015, I was a few years into college working on my computer science degree. I was through a few classes and wanted to get more "involved" with development and technology in general. One thing I thought would help me accomplish this was to move completely to linux. The had another benefit in that the laptop I was using at the time was aging, and feeling pretty slow day to day. So the hope was wiping out windows and installing Linux would give it a little more legs.

So I grabbed my old 15 inch "Samsung MK1 brick", and a spare USB and went through some tutorials for installing Ubuntu and didn't look back. After a weekend of troubleshooting, I was completely on Linux. I didn't realize at the time, but this experience would indirectly lead me to all sorts of things I'd need to learn and use in the future, simply by forcing myself to pick it up due to the switch. It was "basic" stuff like learning how to use the terminal for basic day to day tasks like moving around the file system and writing and editing files.

After essentially forcing myself to learn linux or "drown", I shopped around different distros, different terminals and different tools. All to find stuff that not only looked cool, at least to me, but to also learn what was out there. I spent a good year using terminator and transparent terminals to take notes and review the slides on my laptop at one time. Eventually I was able to upgrade away from my "Samsung brick", and again made it a goal to use linux full time with my newer laptop. I stuck with Linux for a number of years until wanting to simplify my life and moved to Windows 10/11 with WSL2. I've kept linux around in dual boots but found I never entered them enough to justify it. That said, with WSL being mature enough to work more or less full time in it, while still having access to a linux environment, its a nice "best of both worlds".

Around the time I got this newer laptop, I ran into some of the "core tools" I started to pickup that I still use today.

Those tools are:

• Vim
• Tmux

To be completely honest, I felt like a hacker using a multitude of terminals with all these fancy gizmos. I even used it heavily during my on C programming class, and felt not only like a real coder, but a "cool" one lol. It was useful to get used to these sorts of tools, even for basic usages like what I was doing, but I wasn't actually doing much more than just leveraging the terminal for tasks I could use a GUI text editor for. I like to compare the level of commitment to that of using something like notepad—useful but nothing fancy.

Inbetween years​

I eventually moved on from these tools for anything but basic usage. My Tmux and Vim setups were never too fancy or tricked out. There was a point where I had tmuxline+airline configured, but one problem I always ran into was integrating it with my different computers I'd use. Even in college I had 3 different laptops I'd use ("the brick", the main laptop, and in my last year I purposefully swapped to a chromebook), this didn't include any of the random raspberry-pi I'd buy to play around with as a basic server/terminal, or my main desktop computers, which I didn't do much development on, but sometimes did. The end result was either trying to share a common config between all of them through a dotfiles repo, and then dealing with it exploding on my newly minted raspberry-pi, or trying to configure each manually.

Because setting up and integrating these tools was too annoying between these different systems, I kept my Tmux and Vim setup pretty small, I never even made the jump to Neovim until a few years ago for a similar integration issue. So my config stayed more or less the same for about a decade (!) I only used Tmux to run dev servers, or individual tasks like git, and use Vim kind of like a notepad, only for basic edits like git commit messages. I was using Atom and later VSCode once I got into TypeScript development, and I never really looked back. VSCode did all the "actual work", up until I started gaining access to "agentic IDE" tools such as cursor (which is honestly just VSCode with some other features).

Jumping to today​

So this brings us to today. I finally have invested some time into my setup, and like most things, this has been largely possible only because of AI helping me grind down on some common issues, and saving the "brain juice" for the direction, rather than the syntax. That said I had a heck of a time with the current setup, even with it being only a week or so old. That said, I enjoy it thus far. So here it is:

• Tmux - still going strong!
• Helix - replaced Neovim, more user friendly, easier to tweak and jump between files, still using as a reviewer
• bash - I tried out zsh and fish shortly but I never could justify it enough

A few other things I've integrated into the "terminal tooling flow" I picked up over the years are:

• github-cli - work with git without leaving the terminal
• copilot-cli - leverage AI/copilot without leaving the terminal
• starship - cross platform prompt, useful out of the box without me tweaking anything

tmux today​

Tmux does the same job as it did years ago, with it being one area that I've invested the most into as of late. The job is the same, but how I went about it is completely different. Namely, I removed a bunch of stuff I had setup originally to focus only 2 things:

• window management
• session management

I have a few other things I'm currently looking into tweaking/improving, but I largely removed stuff like:

• hostname/user name (actually going to make a comeback!)
• git information
• computer information - I got fancy with battery level/CPU usage/time/etc
• random scripts for statuses - these broke when I jumped machines, and never bothered to fix them lol

Helix​

I've used Vim for years, but never got pasts the basics simply because I could never devote enough time or effort to learn it and keep track of it. There was multiple times and attempts for learning and trying to go from "notepad" levels of usage to more and I just couldn't get over the hump.

I was suggested Helix by someone, as I was searching for newer age alternatives, and Helix fits the bill. It follows similar philosophy as Vim in usage, but the actual user experience is miles ahead. With the main "features" being forefront, such as file searching and finding, all with helpful popups showing what other options there are.

There's also pretty sensible defaults out of the box and a simple way to configure its status line. I mixed in some copilot magic to make the them almost match my new simplified Tmux config, and have been off to the races.

Sticking with bash​

I tried out zsh, and even tried to use fish a few times over the years but I just don't see much benefit. I'm at a point where I want simplicity over any specific features.

AI is the reason​

Like most posts I write about now, this all circles back to AI. On my personal machine I largely use just copilot-cli due to its integration with VSCode and github. With Helix managing the "review" and all this occurring in different Tmux windows/sessions, this setup runs great, while staying out of the way. That said if I need to code a lot myself, I still keep VSCode nearby.

But VSCode still is around​

I still use VSCode for a majority of my personal work, and haven't fully moved away from it even with all these terminal tools. I go for it every now and then, but if I have a lot of work lined up, I stick with what I'm used to. That said, all the work I have for this blog is now being written in my new setup!

The tooling​

The last thing I changed was I built my "installer" in native typescript+nodejs so I can review it easily. This installer is a CLI app that allows me to do stuff like backup, install, verify, and even see the difference between whats on the current system and what I have in the dotfiles repo. Its always a WIP like most of my projects, but thus far has been working great!

Screenshot of the setup and simple breakdown​

Enough talk, here's how the setup looks right now.

The tmux session list is on the left, with the current system name separate by a simple | character, with the current session denoted by [].

On the far right side (I don't use the right section so the "middle" gets pushed to the far right) are the windows.

This system allows me to have 2 levels of "tasks", and multiple windows each with their own panes as needed.

The dotfiles-2 repo​

Here's the repo if you want to take a look! repo

Introduction​

One reason why I started this blog is to create a space that is intentional about its use of AI, with a clear goal to not actually leverage it for content generation. That said, this blog does use AI for a number of other things, which I'll go over in this post.

This blog utilizes a few of the AI standards I mentioned back here, along with some specific tools and workflows I use to help maintain it without spending too much of my limited personal time. These standards help solidify how I want to use AI in its limited capacity.

Repetitive tasks​

Dull development tasks are actually pretty common, but also a subjective topic. If you ask one type of dev, "writing unit tests" could be considered dull, whereas others writing critical software would consider unit tests critical and not dull. There's even a "developer term" for all this dull work, it's called "boilerplate". A blog is not a boilerplate heavy use case in regards to code, especially this specific version of the blog where I more or less leverage a pre-existing tooling in the form of Docusaurus. However, building and maintaining this blog still ends up having some "duller" moments.

The best example I have is the utilization of an agent skill, to help create new blog post boilerplate. Docusaurus blog posts utilize front-matter, where I follow a specific format for blog post titles, tags authors and dates. This is fairly easy to write myself, but having AI do it means saving a few seconds to kickstart a new blog. This of course isn't super impressive, but I did have a few instances in the past where creating a blog post incorrectly ended up causing some issues with the build, and ended up wasting a few more minutes of my time that could have been spent writing or fleshing out ideas.

Fixing and expanding tooling​

Docusaurus comes out of the box with a number of useful defaults, but I've had to tweak and change a number of things as the use-case of a "blog only" site is a bit different than the default "docs and blogs" use case. Along with this, I had a few customizations I wanted to add and work on, such as the "recent posts" on the main page, is actually a Docusaurus plugin I had Copilot write based on the docs. The styling of this doc was also "vibe coded", as I didn't want to deal with playing with color theory, or tweaking values continually. Copilot did an OK job at this that created some accessibility issues that still somewhat exist. But this again saved me a ton of time I spent writing more posts than tweaking colors.

Copilot has also fixed a number of small bugs that would have only taken me a few minutes to complete.

Workflow and tools​

The main AI agent/tool I use is Copilot. The main reason for this is my use-case is not complex or fancy enough that I want more advanced options or fancy tooling. There is also one killer use-case for Copilot I haven't found an alternative for. The most obvious use case is simply booting up VSCode, opening the chat right sidebar and telling Copilot what I'd like it to complete. I use this pattern for creating new blogs, or fixing issues I know about and want to observe or guide myself.

The second more advanced case is assigning and writing github issues to Copilot on github. This works way better with a more detailed issue, along with keeping Copilot to focus only on small specific tasks. That said, I did have Copilot generate a number of core infrastructure, such as the deployment pipeline, adding in playwright to help test a build and test for accessibility issues. For example, this is the issue template I assigned to Copilot:

## Description

Playwright can be used for testing the build and look for accessibility issues using axe testing.

This can test the digital ocean PR deployment 

## Why

To verify accessibility and the actual website works and loads properly 

## Tasks (optional)


- [ ] research latest version of playwright and docs
- [ ] install the library using the documented method
- [ ] verify install against the example tests that should be installed automatically 
- [ ] modify the installation to test the built site, verify the search bar exists and works, verify the blog post list, verify an article loads and tags redirect to the list of tags
- [ ] verify these test work in the PR build
- [ ] add axe accessibility testing to the playwright test and have a test for the homepage and a blog post
- [ ] re verify the PR build 

This resulted in a solid initial PR, of which the only feedback I had was to ask Copilot to consolidate the github action yaml files and reuse the same build step. But overall this worked and saved me easily a few hours.

The final "killer use-case", at least for me personally, is I can write issues, and assign Copilot, and review its work all from my mobile device. This, for me is a great way to get ideas going and something in motion without anything more than a solid description of the issue. I was able to solve a number of smaller bugs all without being home, simply because I had the ability to dictate and control Copilot through the mobile app.

Future of AI tooling in this blog​

Practically there isn't much in regards to utilizing AI specifically for this blog, its already setup to handle maintenance issues, and has done a solid job at solving issues I don't want to spend "brain juice" on myself, so using a more fancy option, or fancier features just probably won't happen here. That said, I always have other project ideas, vibe coded and otherwise. These sorts of projects are probably something I do my usual "start quick and lose enthusiasm, stop and let it gather dust". With AI I hope I can actually get some of these off the ground more. Still, I acknowledge the environmental impact of using AI, which I plan to write about more in the future.

Until next time, keep learning, keep building, and keep asking questions!

I like standards, you should too. Especially when it comes to AI, which is still somewhat a wild west. Having some standardization helps with transferable patterns regardless of what agentic AI tool you are using.

Introduction​

First and foremost I want to define the term "agentic AI", as this post will be entirely targeted around what this term means, and how it's used. I'll also exclusively use the term "AI" to refer to LLM powered AI systems, at least in regards to those used by developers.

Broadly, most AI agents developers use today are "agentic" with different levels of autonomy. Earlier versions of AI would provide suggestions, but aren't able to write code themselves without developer acceptance. However, today with tools such as Cursor and Claude Code, developers can just write a prompt and these AI tools will go off and perform any number of writes/reads/tool-calls/etc. to accomplish the task.

With all these different agents, and ways to define and do things, some standards have come about that help developers define some guardrails and capabilities for these agents to leverage, without defining the same things over for each type of tool.

AI Standards​

I'll go over 3 standards I know of, listed in order of how much they are currently supported by common industry standards to different degrees.

Broadly speaking a lot of tools that don't support these standards, already have some internal form of these standards, hence why these standards came about, there's a similar need for them.

• MCP (Model Context Protocol) - "MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems."
• AGENTS.md - "A simple, open format for guiding coding agents. Think of AGENTS.md as a README for agents: a dedicated, predictable place to provide the context and instructions to help AI coding agents work on your project."
• Agent Skills - "A simple, open format for giving agents new capabilities and expertise. Agent Skills are folders of instructions, scripts, and resources that agents can discover and use to do things more accurately and efficiently."

MCP (Model-Context-Protocol)​

MCPs are a standard created by Anthropic back in 2024 (ref), for ways for AI to interact with tool calls. The term "MCP" is both the name of the standard, and the name of the "server" that provides the actual tool the AI agent can interact with. The standard defines how the tool provides information to the AI agent so the AI agent can decide when to use the tool and how to use it.

Examples would include:

• GitHub's MCP server - interact with GitHub's API via MCP/AI
• Azure MCP server - interact with Azure via MCP/AI
• MongoDB MCP server - interact with MongoDB via MCP/AI

MCPs are largely how you currently change how an AI agent interacts with the world beyond the context already given. Day to day you could automate tasks such as creating issues, managing cloud resources, or querying databases all using the same "interface" of the agent.

However, MCPs come with a few core drawbacks:

• Due to how the standard works, the tool calls each populate the context, so the AI agent will always know about them, and knowing about them takes up the working context or memory that the AI agent can use. This could confuse the agent, or at a minimum increase costs due to more context being used even when not relevant.
• MCPs largely interact with external APIs, which requires their own auth. The standard has no defined way to handle auth, so each MCP server implementation has to define its own workflow (often API keys) for handling auth.
• Because of these API keys, there isn't a transferable standard or format for sharing MCP servers, each developer has to set up their own settings.
• MCPs are largely a core attack vector, as like any tool call they can be used as a way to gather information, or perform prompt injections.
• How and where you define your MCP servers is also not standardized, so each tool has its own configuration format. Largely using a JSON settings file, but again I don't believe this is standard, and only a convention.

Even with these drawbacks, as a developer it's hard to get away from MCP tools, as even a few core ones can greatly increase productivity. But don't give it write access to the DB!

AGENTS.md​

AGENTS.md is a standard created in 2025 by a "collection of industry efforts", so it's relatively new. But it solves a core/common problem almost all AI coding agents have required. Which is automatically provide some context to all prompts. As stated in the site description, AGENTS.md can be thought of as the README of a project, but for AI agents.

Practically this means defining a file named AGENTS.md in the root of your project, that contains specific sections that the AI agent can read to understand how to work on the project.

Here's a snippet example from the AGENTS.md file, of the blog/site you are reading right now:

<!-- ... -->

File used for AI agents documentation. Each subsection provides examples and descriptions for different common tasks.

## Architecture and Technologies used

Uses Docusaurus@3 for static site generation, React for UI components, Markdown and MDX for content and typescript for any React/node code. Runtime for development is node@24 and deployment is through GitHub pages.

## Folder structure

- `blog` has `md` and `mdx` files for blog posts.
- `src` has all css, React and typescript code.
- `static` has all static assets deployed with the rest of the site.

## Scripts

- `npm run build` - script to build the static website.
<!-- ... -->

I've gotten some mixed signals about what you put into AGENTS.md and what you don't. Practically you shouldn't put too much, as it's always provided to the agent as context every time, so you want to only put in things that are always relevant.

Agent Skills​

Agent skills is a new standard, to the point most AI tools don't support it out of the box, but it's a standard that mixes aspects of both MCP and AGENTS.md together. They primarily allow you to define complex workflows and capabilities within markdown files, but are more lightweight compared to MCP calls.

A skill is defined within a folder structure at the root of a project:

.skills/<skill-name>/

where the skill name of the folder will correspond with the "skill name" in a markdown file named SKILL.md within that folder, so if I had to define a skill named "code-review", I would create the following structure:

.skills/code-review/SKILL.md

Within the SKILL.md file, you define a frontmatter section with the properties name and description, where the name corresponds to the folder name, and the description is a short description of what the skill does. Critically these two properties are the only properties the AI agent "sees" in its context at all times, hence the lightweight nature relative to an MCP server definition.

Within the actual SKILL file you can define whatever you want to give to the agent, when it determines to use the tool call.

So for example here's the skill I have defined within this project to help create boilerplate code for new blog posts:

---
name: create-or-edit-blog-post
description: Use this skill when the user wants to create or update Docusaurus blog posts.
---

# Create New Blog Post Skill

This skill helps create boilerplate for new Docusaurus blog posts.

## Quick Reference

### File Naming Conventions

Blog posts in the `blog/` directory should follow the following naming conventions and folder structure:

- `YYYY/MM-DD-title.md` - Date-prefixed filename
<!-- ... -->

This standard is still new, so I haven't been able to leverage it. Most AI systems have a similar capability, or at a minimum you can just directly reference a file directly for extra context, as almost all AI agents have the ability to read a file and thus add its content to the context.

Conclusion​

So in review, MCPs are the "tool call" standard, and AGENTS and Agent Skills are ways to provide more context either all the time or situational to agents.

Hopefully that sheds some light on AI standards, as I know them and use them.

This post is also the first one I've written specifically to help me review and gather references for things I know about but want to drill down a bit more. Day to day I use these tools multiple times, but writing it down and shipping it out on this blog is one of the main goals I have for this year. So hopefully this won't be the last post like this. As a taste of what I have in mind for the next part, I'll probably write another AI oriented post around how I use AI specifically for this blog itself. Again I don't use it for writing these posts (hopefully you can tell... for better or worse haha), but I do use it elsewhere.

Until next time, keep learning, keep growing and keep asking questions!

Welcome to the first official "reading" post of 2026! As mentioned in my previous post, I wanted to split up development and reading topics into their own posts so I can focus on each a little more. This way I have something more targeted to write and ramble about rather than combining what is usually two somewhat disjointed topics. I of course do more than code and read, but in regards to actually writing about it and shoving it onto the internet, I think these two topics are good targets and worth writing about and hopefully worth reading!

Books read in 2025​

Due to writing this months later I'll provide the raw list and a general summary of each. In the future I think I'll write a more dedicated focused summary as I read them. Mostly as a way to review it, and to buff out how much content is in this blog so it doesn't look as dead help pass along what I felt.

Here's the list of books I grinded read in 2025, roughly in order of reading (or at least based on my good reads list haha):

• "The Far Reaches Collection" (5 short sci-fi stories):
  • "Just Out of Jupiter's Reach" by Nnedi Okorafor
  • "The Long Game" by Ann Leckie
  • "How It Unfolds" by James S.A. Corey
  • "Void" by Veronica Roth
  • "Falling Bodies" by Rebecca Roanhorse
• "The Disturbance" by Brandon Q. Morris
• "The Disturbance 2: The Answer" by Brandon Q. Morris
• "The Disturbance 3: The Truth" by Brandon Q. Morris
• "Kosa" by John Durgin
• "Red Mars" by Kim Stanley Robinson
• "The Circle" by Dave Eggers
• "The Every" by Dave Eggers
• "Artemis" by Andy Weir
• "Forever Peace" by Joe Haldeman
• "Forever Free" by Joe Haldeman

The Far Reaches Collection​

Being one of the first things I read last year, I have a tough time recollecting my exact review for this collection. Overall it was nice to dive into a book you can complete in essentially 1 sitting. Each had their own ideas and fleshed out stories all in a short snippet. I grew up reading Ray Bradbury short stories and compilations such as the "Illustrated man", so this was a nice way to go back to this format without diving, or grinding out longer books.

The Disturbance Series​

I've found I go back to Brandon Q. Morris pretty often. His stories are on the "leaner" side of sci-fi, with some core science concepts, but the stories are largely character driven and carry a consistent pace. His books are also all reasonably priced, but the stories are almost always drawn out over multiple books. It is interesting to see some characters mention or pop up in other stories, but each series is largely self contained. The Disturbance trilogy was no different, but I did realize part way through I "skipped" a series earlier, which I'll have to possibly go back and read.

Kosa​

I don't often read non-sci-fi, but Kosa was an exception mostly because I read the summary and it sounded like the Disney movie Tangled, so I bought it on a whim.

It was a fun and somewhat brutal read. If it was a movie it would be the sort of film that ropes you in with that same premise of sounding like something Disney would make, but then start the book off with some brutal rated R violence.

It was a pallette cleanser from all the usual sci-fi I usually read, but of course after reading this one I went right back to sci-fi, with a modern day classic.

Red Mars​

I've heard about the Red Mars trilogy for years, but never got around to reading it as its one of the newer sci-fi books that was famous enough I've kept it on my wish list for a few months before pulling the trigger and getting it.

This was unfortunately the "slog" book for this year. It seemed to run on for a while, and felt like a long and unfocused read. The characters were interesting but due to the changing nature of the book, which spanned decades(?) I think it lost me about mid-way through afterward, which I eventually finished but more out of obligation than interest.

There's 2 more books in the trilogy but I'll probably hold off on them until I find another gap in my reading schedule.

The Circle & The Every​

Another newer sci-fi pick.

I only picked these up because I saw the movie recommendations (another possible blog topic!)

The Circle was an interesting read that was fun to read and talk about. It was satire, but not so outrageously so it had a slight edge to it I feel like. The ideas it went over seemed semi-reasonable and that made it somewhat scary to be honest.

The Every doubled down on this premise but felt more like outright satire built out of the pandemic. Both felt like a continuation of the same story, but the characters in the second book weren't as interesting in my opinion. There was also a few open threads that were only implied from the first book so it wasn't that much of a direction continuation, but rather an extension placed in the same universe.

Artemis​

I like Andy Weir, full stop. But, it seems likes he can only really write one protagonist, based upon The Martian, and one of my most favorite books, Project Hail Mary. I left Artemis for last because I knew it was the worst of the three, but I wanted to read it anyway as a way to hopefully fill some time until the Project Hail Mary movie comes out, which I'm very hyped for.

Artemis, like the other books, was an easy fun read, but you can see the "Mark Watney" character all over the place. The plot also didn't really lean into such a witty character. The environment and world building were interesting and fun, but yea I agree its the weakest of the three. I didn't not enjoy it, it just made some very odd choices I feel like and Weir's insistence on writing essentially the same primary character in all his books didn't help.

Either way, I'm still far from Project Hail Mary coming out on the big screen, so I might swing back to that book and write about it again before then!

Forever Peace & Forever Free​

Fun fact, one of the first novels I read, and why I got into sci-fi in the first place, was I read the Forever War by Joe Haldeman in back in middle school. My English teacher had a small library in her classroom and offered to loan out books to any student interested in reading (she was really cool like that). I picked up Forever War, specifically because the cover had a really cool soldier dude, the title sounded cool, and the book was brand new.

I've read it a few times now, and finally got around to picking up the semi-sequel and direct sequel.

I consider neither as good as the original, with Forever Peace introducing a number of interesting aspects, but like Forever War, coming to a somewhat abrupt, almost out of nowhere end.

Forever Free continued the story of Forever War and went into some interesting places, but it too fell to what I felt like was a huge weight of expectations to essentially pull a complete "deus ex machina" ending that felt mostly insane.

Either way felt good to wrap up that long open series.

Catching up from a no activity in a majority of 2025, looking into 2026 and beyond. As with most things, AI has come for this blog, but don't worry this is still very much "human powered" (for better or worse)!

2025 reflection​

First and foremost, welcome to the 4th iteration of this blog! I'll try to get around to writing up a new post on the previous 3 versions at some point. As I find it an interesting journey, as each iteration was created with specific goals in mind which is a reflection of what I'm interested in learning at the time. This version is no different, which I'll touch a little on below.

2025 blog activity was just a single post which I wrote late in December specifically to point toward this new version. Now that you are reading this version, the transition is complete! I dated this post when I wrote it, but odds are it will be a while before it goes "live" along with the 4th iteration.

Because 2025 was so sparse, I want to dedicate a little more time into writing what I've been doing in regards to development, reading and a few other tidbits. So without further ado, here's how 2025 went in regards to development!

2025 was the year of AI tooling madness and some clarity​

2025 was the year I started to really look into using AI in depth. I was already using some AI tooling to a degree with early versions of github copilot, but made it a goal to leverage these systems now that they have gained some level of maturity.

Without getting to in depth with specifics, after using a few "agentic AI" IDEs, I realized that github copilot is starting to lag behind, and more aggressive tooling is available. Also, around this time the MCP standard started to get implemented in the tools I was using (copilot included). I started to see the practicality of AI to help not only with development, but to provide a flexible component for automation. Most people talk and focus on the "intelligence" aspect, but I only see a flexible tool that is "artificially intelligent". When pushed AI intelligence falls apart pretty quickly and somewhat obviously in some cases.

For example, if you asked your AI agent what the weather is like, it has no clue what outside is without making some tool call, or web search. It's just acting as the middle man to synthesize a response. This can help, as it can customize the response to your needs and demands, but it's just as clueless about "what outside is" without these external tools. This can be found with some specialized agents, where you ask it what time it is and if it doesn't make a tool call, it will give an older date that aligns with its training material. Or it will tell you outright its own limitations. It isn't magic, it's just how the system works.

That said, me being an automation guy means I've looked for ways to utilize these new tools to build systems and processes that save people time. Even though all LLM powered AI systems now are largely built on theory written decades ago, the scale of these models makes them still pretty powerful at recognizing patterns, and even without integrating with other systems, still a useful flexible part of a systems stack.

It's only once you start to get an AI agent, and integrate it with the outside world you go from a chatbot trying to mimic intelligence, to an autonomous system that can execute tasks on its own, to varying degrees.

There's been a lot of hype around how far AI could actually do, but at the time of this writing it seems like most of that talk has turned out to be closer to sci-fi than reality, with studies such as the MIT review, which found a majority of AI projects fail, or the Apple study that points to the lack of actual "thinking" within these agents.

This brings me to the point of clarity that I'm focusing on for 2026. Which integrating them into positions where their raw flexibility can be leveraged, while avoiding core limitations and expectations that largely stem from not understanding how the systems work. This largely gets into a few key points, which I'll list below but probably go into more detail in future posts.

• LLM powered AI's are built and defined by their training data, whatever context you give them, and what tools they can integrate with.
• AIs aren't so much intelligent, but faking intelligence. This doesn't mean they aren't useful, only the premise of them being "experts" is fleeting beyond a critical point.
• AIs are more tools or systems that can be used within an application to solve very specific problems, that ultimately only work due to their flexibleness, not because they are the best option.
• If context is most important aspect of leveraging AI, then effective validation is the second most important aspect of leveraging AI.

After playing with AI, using it, working within it and trying to take it to its limit, I've come to the conclusion it isn't going anywhere, but it needs focus and work to leverage correctly. Which is one reason I'm back to dedicating time back to this blog.

So how do I plan on using AI for this blog in particular?​

Who doesn't love a little AI slop? Just kidding, I assume you are only reading this because you don't want to read AI slop. I promise to avoid that and write my own way, for better worse. That said, I will use AI for a number of "behind the scenes" work, along with acting as a broad editor to help fix any invalid grammar or spelling mistakes.

I will not give the AI a prompt to write a full article, I don't believe that is worth anything to anyone.

I will let AI help me handle this blog's files, technical stack and other tasks that "take up brain juice" that aren't directly related to writing.

Personally I think AI as a tool should stay a tool, and it will be used as such. Trying to elevate it beyond this sort of post or use-case is somewhat unethical, and non-genuine. Plus I think AI writes too much like a robot, you can tell when something is written by AI. It usually tries way to hard for no reason.

So yea, AI is here, but not where it counts!

So why a new blog version?​

This new version is built using docusaurus, with the main goal being offloading a lot of random hacks I had previously implemented, along with providing a clean "AI first" slate. This new version is focused almost entirely on the "blogging" aspect, with removal of stuff like "projects" as I feel like this is more important at this time. When anyone can create an MVP in a weekend, my weekend projects aren't any more impressive to talk about than any random vibe coder burning tokens.

I also wanted to dedicate myself to more deliberate deep thinking, and part of that writing, hence why the simplification and focus around the blog.

That said I have a few technical goals for this version beyond just leverage AI for maintenance, and out of the box docusaurus features. Namely I want to finally get around to cross posting/support with dev.to. I enjoy that platform as one of my main sources of learning and keeping up with trends, so I thought it would be interesting to try to write to it and here. Will have a blog post about that... if I ever get to working on it!

Finally, the old version is just "old". It hasn't had activity and I thought it would be a good time to leverage AI to build out a new clean slate, and help keep this maintained going forward.

Summary and goals for 2026​

I've already started on some new books unrelated to sci-fi, which I'll try to slot in some time to write about in the first dedicated post.

At the same time, even though this post has been written, the site/blog itself isn't published! I'll be working on getting that in line at some point in the next few weeks hopefully.

• get back into open source development, specifically getting up to speed with a few libraries that have been neglected
• write more blog posts, around specific topics worth
• cross post this blog with dev.to (mostly because it would be cool)
• setup a time and place to spend time writing and working on this site, I have a plan to schedule this in but we will see if I follow it!

And with that, welcome to 2026, keep learning, keep building and keep questioning everything!

A year in review

2025-12-27-blog​

The last blog for this platform!

So as you can see if you go back through this site/portfolio, this blog has been neglected just like most of my projects. Just like this blog, and the 2 versions before it, its also time to try out a new setup, and new focus with the new year.

So this blog will go away and make way for a new one that removes the portfolio/project aspect, and focuses entirely around blog posts. With some of the original ideas I had for this one continuing.

The other big change will be the framework used, this blog version has used nextjs with the goal of improving SEO with static site generation. The process was enlightening, but the next iteration will actually become simpler/more straight forward.

The new version will actually use docusaurus as the main framework, with some underlying plugin code that I plan on writing to leverage dev.to to auto-cross post, with dev.to being the source of truth.

There's no real reason for utilizing dev.to over other platforms, besides it seems like the simplest to leverage. With that, the next post (whenever it actually happens) will be in the next framework/iteration!

I'll also carry over the previous posts into the new one with slight modifications.

See ya there!

Keep building, keep learning!

A year in review

end-2024-blog​

Goodbye 2024! This is a long one, possibly my longest. Again using this as a journal/post-it-note for myself in the future more than anything.

Yes its only November, but I wanted to get this in while I have some time to go thru it, and clear up this site a bit and close out some older issues/ideas I wont be able to get to.

Its been an interesting year with a lot of personal changes on my end (no I wont go into them here!), so this year from a developer perspective hasn't been much more unique outside of the usual. I did keep up with some guitar practice, learned a few new licks and have kept it somewhat consistent lately. Will continue to spend time practicing while I can and just enjoying time with the family!

Going into the new year I plan on expanding some of my developer skills, and cleaning up my github. I think its time to do some spring cleaning and updating some of my super old repos, and also finishing some features completely missing from my chrome-neo-plus project, which is live, even without key missing features. Sorry whoever actually is using that thing!

Coding update​

So there's been 3 main things I've been looking into on my end worth noting:

• looking into modern compiler options with vite/rollup
• looking back into go
• leveraging more AI in my day-to-day

Beyond these, I'm looking into gearing back up into open source related work, along with cleaning up my github.

Vite and rollup, the future?​

I've lost track of nx development and updates, as I've focused more on lower level tooling in the form of newer bundler technologies such as rollup and vite (which I think use ESM Build under the hood? I forget.)

I've been interested in them as another gap/knowledge area I think I should expand on as a developer who is always interested in using better tooling to improve the developer workflow. I'll keep looking into these in my spare time mostly as a curiosity, as I can't think of many personal use-cases where I'd want/need to tweak anything beyond the presets already out there.

Personally I think if the web ecosystem moves past webpack based tooling, these rust based ones seem like the way to go. Which leads to my next topic. Either way I'm going to be looking back into nx updates and its ecosystem to see where it is nowadays.

An old interest, go​

Go or golang is a programming language I've been interested more or less since it was announced. I stopped focusing on it since there was very clearly no reason for me to look into it with the ability to use nodejs as a web developer. However, I feel like I'm at a point where I should expand my horizons a bit more and gain more practical experience with some newer technologies.

As such looking into a language I've always felt good about seems like a nice change of pace. Go has gone thru a number of changes the last few years, but the overall language and ecosystem is the same. I'm not sure if I'll be able to leverage it day-to-day at all but I'm looking at a few smaller projects that might work with go, rather than nodejs.

See if I post about getting any of this done next time!

AI here to stay, but still not impressed much​

I've been seeking to leverage AI more in my every day life. I still use github copilot to help get "fancy autocomplete" and help with larger niche use-cases, but lately I've also been using github gemini for more generic tasks (not chatGPT, because I'm still on the google train!). Its been helpful in some aspects but I still don't feel like it does much more then help digest what I could find on the web in a majority of cases.

I'll still be looking to leverage this more in the common months, but I'm still a huge skeptic. I can't see it going away, but I also can't see it getting much more useful outside of more integrations with other tools. For example I had Gemini act like an editor/reviewer for this blog post and asked it to give hard recommendations of improvement and I only got some high level examples, and even less hard examples that are obvious. I'm not sure if the size of this post impacts it or what, but I'm not impressed. And no I didn't accept its recommendations either!

I still firmly believe AI is still best executed as a "UI" for interacting with a complete system generically. The more integrations and the more powerful those are, the more useful the AI will be. "AI as UI" is also something I'm actually thinking about looking into more in this common year as a project idea, but we will see!

Book update​

I made a very key (and perfectly incorrectly timed!) purchase in the last few months that really pushed my reading into a new level. I jumped onto the boox palma train at the exact worse time. For those that don't know, the boox palma is essentially a phone sized e-ink-reader that runs full android, so you can install any android app and use it like a kindle/e-reader but also do most thing a phone could, such as browse the web, check your email and even watch videos (its possible, but its black and white and not the best experience).

I've used this device to replace my kindle and it fills an interesting niche as a device where I can read both kindle (via kindle app) my google play books, and still read stuff on other apps such as wikipedia (for wikipedia dives lol), feedly and libby (library app, hopefully to replace all other apps). Reading stuff on it has been a huge pleasure, which is reflected in my book review below.

Unfortunately, I got this device at the perfectly wrong time as shortly after I got it, they announced the second version and put the first version on sale. However I'm happy enough for now with this current version I'll just suck it up and stick with it until I run into more issues lol.

In terms of actually reading I've grinded thru a good amount of books this year, some I've wanted to read for a while and some other's that I just randomly picked up. Some key ones:

Starship troopers and 1984​

Both of these are name-brand classics, however both felt somewhat like a chore to read. I think its because these are both well known enough that going into them I more or less knew what to expect. That said both fall prey to simply feeling like they overstay their welcome in some aspects. Its highly likely this is just due to being older books written in a different time for topics that were more intriguing years ago, but have been retold/redone so many times today that they feel less impactful.

Either way I'm glad I read them, but I found the other random picks to be more consistently more "fun" to read.

The Midnight Library and Mickey 7 (series)​

These ended up all being "page turners". With the Midnight Library being one of the few books I read that isn't sci-fi, but it was an engaging and interesting piece.

I grabbed Mickey 7 once I heard about it being made into a film (or series?) and it was a hugely fun read. Looking forward to seeing how they adapt it, as I think it will be a fun watch.

Multiple other titles​

I read a few other titles not mentioned, but its more sci-fi. Some good, some bad/boring enough I didn't actually finish. I have a (virtual) stack of other books and more currently ongoing I'll save for next time to talk about.

Closing​

This was a good year for me, a lot of good stuff happened (a lot more than I mentioned above). Its been an interesting time to be alive, and I'm grateful for what I've gotten and experienced. Looking forward to 2025 and beyond, and I hope you are too!

Until next time, keep learning, keep building!

A year in review

new-year-newer-stuff​

Welcome to 2024!

I've slowed down working on my github profile, and any public projects. Work has been sucking up most of my "developer" energy, and I've had a lot going on in my personal life thats been taking up a lot of my time as well. Just not enough hours in the day!

The only project I've tried to stick with in my free time (besides this site/blog lol) is my chrome-neo-plus project. This project has a "deadline" in that the original will get removed from the chrome-extension store due to being on an older manifest. This deadline is June. I'm getting close with my new version and hope to get it out just in time, but we shall see!

The only big thing to note is I've gone back to practicing guitar again. I used to play back in high-school, but stopped once I went to college. Picking it back up is a nice way to take a break from screens and just relax. See if I'll be able to keep it up!

Book update​

I read a few more books to close out 2023. I read all of the "silo" series, which were great sci-fi reads. I don't have Apple TV so I wont be able to watch their show, but I'm sure its good.

I also read Old Man's War. I got it on sale, and it was a pretty entertaining read with a rather hilarious, but interesting premise. I'd consider it far less "hard sci-fi" than I usually ready but it was a light and easy book to fly through.

Finally I also read a physical book that I've had for a number of years and finally got around to reading it. Delta-V. Was an interesting near-future read about near Earth asteroid mining.

Looking forward I think I'll read a few more non-fiction books before looking back into maybe picking up a full series of books, or continuing with Dune, which I paid for but just never felt like getting through.

Until next time, keep learning, keep building!

A year in review

Review of a year of React​

Its been a little of a year since I've started using React professionally, and also been a number of months since my last update to this blog.

One of the key reasons for this is I wanted to update the dependencies of this project to get things aligned with the latest release of nx before expanding on it. Now that I've gotten out of the way, I can finally get around to adding more content!

So after using Angular for a number of years, then having to pickup React for work I went into React with an idea of the general ideas, but really wanted to get into more in-depth knowledge of how it works in practice. To get this I needed to use it, and that would just require time applying myself to using the library in different aspects. This took some time, but I think I have a good idea of how to move forward, and deal with most use-cases I've come across, or could come across.

So lets go to the list!

React is simpler conceptually, but is more limited out of the box​

This is a pretty obvious one that is usually pointed out, but I want to go into how and why this makes React easier to use, but also more annoying to work with in some cases.

Personally I've found there being essentially only 2 types of "tools" React provides to solve all your problems.

• component
• hooks

Yes there are a ton of hooks (will go over that more later), and other patterns such as Context, and different types of components, but just these two "tools" end up being the core fundamentals implied to solve all of the problems you could face building user interfaces.

This keeps your options simple, but forces you to know how to wield them correctly to solve all the problems you come across. The few "gaps" in available patterns between Angular and React could be re-built or "re-implemented" using just these tools, but it could require some extra legwork that you just don't get with React out of the box.

React hooks are more important than components​

Coming from Angular, where there's any number of ways to do something (services, components, directives, pipes, etc), React is much more limited in what it provides out of the box. However, the concept of hooks, stands out as one of the single most powerful features. To the point I'd consider saying thinking of Hooks as the core of React, and components as just the "view" layer.

Lately I've changed how I create my React UIs around hooks. The pattern I've been relying on is the "single-hook" pattern, which is best compared to the traditional MVC pattern (except with focus on just the VC part).

I create a single hook that handles all the logic for a given component, and then the component itself is just a "dumb" component that renders the hook. This means there's roughly 3 parts:

• "controller" component - acts as a high-level "smart" component. This could be the page, or just a high level point.
• the "state hook" - which returns an object of values+function-callbacks that can be passed into the view components. Internally it could have multiple hooks to further segment the logic, but general acts as the "god-object" to manage most of the business logic. As long as this logic isn't extremely complex the pattern holds. Its easy to split-up code, but that could become a problem depending on what your doing.
• view-component(s) - these are dumb components that take in props from the "state hook" and is managed by the "controller" component.

With this pattern its easy to build simpler UI elements, or at least create what I consider to be testable, and approachable "smart" React components.

Thus far the pattern has worked well and scales decently. If I had to do a complex form, or something with a lot of dynamic logic, I'd consider it only a starting point though.

React's ecosystem is a huge pain​

With Angular there's only a few sensible choices in regards to libraries and patterns. With React there's a ton of choices. Which is both good and bad, its good when what you pick goes well with what you've already picked, but things quickly start spiralling out of control as you start integrating more and more technologies.

For example, I've been focusing on nextjs (which this site is built on) for my side-projects, but have been having trouble keeping up with all the changes and different ways to utilize the meta-framework. Furthermore, I wanted to use tailwindcss, but had issues with it integrating with nx and storybook.

I'm sure there is a way to get all of it worth together happily, but that gets even more difficult as nextjs changes forcing a review of all of the technologies. This is also one of the main driving forces why a lot of my side-projects get paused. (besides me just losing interest!)

Overall its been great though​

React, thus far has been a joy to work with once some of the quirks have been figured out. Hooks are powerful, and force you into thinking and writing code a specific way, but it does make things easier once things are build with the patterns in mind.

Being able to just completely isolate business logic into a singular function makes testing and documenting a breeze. It also makes re-using code between components much easier.

Components with TypeScript is very descriptive and easy to use, as long as they don't get too bloated.

Jest and integration with other tools is better, as React is "king" in that regard.

Features from meta-frameworks have been a blast, and options are everywhere.

So thats more or less been 1 year, and I'm looking for many more (hopefully!) working with React.

Next up is re-focusing on React, and maybe using it in new contexts, such as outside of the browser. See how many months it takes for me to get around to writing a post on that topic!

Keep learning, keep growing, keep building!

Remaking a classic

The last few weeks I've been focused primarily on 2 projects.

1. A Dogfight game remake - a fun board-game remake that is based on the Milton Bradley Game Dogfight.
2. nx-workspace-template - a project that is for a github template that integrates most of common tooling I usually use.

Dogfight game remake​

I've been focusing on this project as its one of the few project where the scope is already defined, which should help keep scope creep down and hopefully let me finish this project. I'd compare it to my "bomb-defuse-utils" project, which I is one of the few truly "finished" projects.

I've been trying out a few more techniques with Nx, Storybook and TS to help build this project. For example, I've been using "branded types" essentially everywhere and seeing how far/useful it is to take such a concept. I've also been taking a TDD + functional approach to help "build-up" the codebase to handle the general game logic.

I'm just about to start on the actual rendering of the UI, so I can actually play something. I've been debating how to handle the actual rendering with Angular and think I have a sensible rxjs/ngrx based solution that should scale well. I'll be aiming to getting the actual board rendering + drag and drop down before applying the actual logic I've already written.

nx-workspace-template​

For a project that is nothing more than setting up existing tooling, this project has taken up a large amount of my development free-time. I've been primarily tweaking github-page support along with trying to integrate a "global storybook" build which would be deployed as part of an "internal-tools" deployment. So far its close, but storybook as usually is being a huge pain.

Whats next?​

I've been trying to update the nx-workspace-template with the hope of getting it to a point where tools I don't always use like Storybook, all features of nx, and github-actions are all leveraged well enough to be flexible for future projects. I'm close, but I still am fiddling with it all the time.

However, I really need to get back to the flash-card-app I've languished over for years now and actually get it finished. Its possible I carry over some of the core logic to a new repo that uses the nx-workspace-template, or I just trudge on with what I have with it before. The plan being is to use that project as a refresher on using firebase for the intercept-game project, which will use Firebase for non-local multiplayer in the future (If I get that far that is!).

Finally, I hope to update this portfolio/blog site more. I'm hoping in the past few months Scully docs/capabilities have been improved to hopefully help with my development workflow. As right now its somewhat annoying debugging a lot of features I thought would work, but just are a huge pain to deal with. I also might update the UI to move away from primer to use either the usual Angular Material, or even maybe tailwindcss.

Book Update​

I re-read "The Phoenix Project" by Gene Kim. I read this book a few years back, and wanted to re-read it on my kindle so I can highlight anything I missed when I read it last time.

Reading the book a second time allowed me to focus on a few key parts that I wasn't to focus on the first time. Such as the "Three Ways" the eccentric character Erik brings up. I knew this was important the first time I read the book, but didn't focus on it as well.

Here's a quote I found explaining the three ways:

The First Way helps us understand how to create fast flow of work as it moves from Development into IT Operations, because that's what's between the business and the customer. The Second Way shows us how to shorten and amplify feedback loops, so we can fix quality at the source and avoid rework. And the Third Way shows us how to create a culture that simultaneously fosters experimentation, learning from failure, and understanding that repetition and practice are the prerequisites to mastery

The other physical book I've started to at least skim is "A philosophy of Software Design" by John Outserhout. I've heard this was a good book that can replace/be-compared to the classic "Clean Code" by Robert C. Martin. I've been picking it up in my spare time to get my eyes of the screen every now and then. Its been an interesting read so far, but I've been taking it slow and steady.

Still making progress, but not where it counts

Hello world 2022!

Its a new year, but same stuff going on for me. The projects I have lined up are still lined up. I also started advent of code 2021, but couldn't get past the first few days due to time commitments and the usual laziness. I may go back and work on that in the future, but for now its on the way side.

The primary effort has been focused on my nx-workspace-template repo. I've been adding common functions and utilities to that repo so it should be easier to get going faster. However, this project is more of the usual "optimize the flow", when really I still need to put the work in to finish the projects I already got.

Beyond nx-workspace-template, I've got the same projects more or less lined up waiting for contributions:

• "Flash card app" which still needs to be finished, and has been paused more or less before anything has actually gotten going.
  • this project might also be migrated to the nx-workspace-template, so things can get going faster in terms of the CI/CD updates. However the costs related to this, as its a private github project will probably explode. So more improvements need to be made on that front.
• chrome-neo-2 chrome extension replacement for my older chrome-neo project
  • this project might actually get replaced with a new version that will use the nx-workspace-template repo.
• advent of code 2021 - continue grinding it out with the advent of code puzzles
• codewars-node-api - I need to finalize the docs on this one and show "some life".

Book Update​

I finished Dune over the break, it was very much a grind. I moved onto a book called "Recursion", but Blake Crouch as a "palette" cleanser and it was a nice read I got through in roughly week. I'm going to re-read "The Phoenix Project" to get back into the spirit of DevOps, and hopefully re-focus on one of the many side-projects I have with the spare time I do have.

Until next time, keep learning, keep building!

Why is everything so difficult?

I spent a good few hours today bashing my head against a feature for this portfolio I just couldn't get working. The basic idea was to leverage scully's transferState service to "save" github API data I load, so I could integrate my github gist snippets into this app.

However, I ran into issues at every turn with minimal insight into what was going on.

1. Github's api is rate limited to 60 requests per hour. I would hit this and only get a small 403 error in my scully build. Furthermore, I couldn't get any further insight into the error beyond the code, so I can to manually add log statements in the library to get any idea that I was getting rate limited.

2. To workaround the rate limit, I got a personal access token and set it up for codespaces. This would of been ok, except I had a typo in my header, and ran into more vague errors.

3. After realizing my mistake, I started on the actual feature where I assumed I could use scully to get the raw data from the api, and then manage it within the app. Instead, I just got the id property and nothing else. I should look back into this part, as I might of overlooked a feature of scully. Regardless, because I just got the id, I thought I could use the transferState service to "save" the full data, if I make a direct call via http to the API, through it.

4. I updated my github api service to make the call, and only got undefined in return. After bashing my head against the service more, I realized the transferState was returning undefined because it was getting an error. By this point I stopped, as this is around the third time scully has directly hidden errors from me, which is a huge pain when the docs are missing so much.

Because of this, I might start looking for alternative static site generators for Angular (or just bite the bullet and not use Angular!). Its one thing to lack features, but to spend so much time fighting the framework itself is just too annoying.

With this post, I think I'll start spending some time on my other side projects that don't rely on scully. The first project will be the flash card app, which is connected to firebase, but doesn't have much UI.

The other project will be the chrome-neo app, which will be a new version of the chrome-neo chrome extension I made for college using angular.js. This new version will probably also rely on firebase, and provide more features than the current version.

Keep learning, keep building 👍

Today I'm going to be updating how I create blog posts, so its a little easier. Along with that, I'll be trying to upgrade this project to angular-13, which recently released.

Hopefully things go well!

other updates​

Work has been busy, so I haven't had a chance to look into my other projects much, but I've had them in mind. I think continuing to update this portfolio is still one of my main priorities.

Longer overdue updates

Happy Halloween for those that celebrate it!

So, I've been busy. To busy to work on side-projects, this site, or even finish hacktoberfest. I was able to get in 2 accepted PR's, but my third isn't finished, and I never found time to get my fourth and last one. I was going to plant a tree this year, but it seems like I wont even be able to find enough time to contribute enough to accomplish that!

Regardless, I've been busy working and handling a bunch of stuff outside of development, like hosting some parties, and going to live events. Its been great to actually get back into things after not doing anything for over a year.

Future Work​

My side projects have languished behind my few hacktoberfest contributions, and I look forward to getting back into them now that I wont feel guilty working on them. I have 2 projects I want to focus on the next few months before the end of the year.

1. Flash Card App - this was the one I mentioned in the last post. The last thing I was able to finish before focusing on hacktoberfest was the actual ngrx+firestore state management. I'm on the side of "its too complex for its own good" right now, but it was a nice learning experience.

2. Chrome-neo2 - the original version hasn't been updated for years. I think expanding on it should be necessary given that the chrome store has changed a number of policies. To the point I'm not sure if my extension can be updated without updating a number of properties.

I think re-looking into chrome extension development with all of what I've learned would be an interesting and fun experience.

Until the next time, keep building, keep learning!

New way to name and generate blog posts

From here on out, blogs will be generated using the same logic as the other types of posts, rather than dates. This should make things more descriptive, informative, searchable and easier to find later.

onto the updates​

I haven't written a blog post in a while due to primarily being really busy. Work has been a lot, sucking up most of my energy. However, I've re-focused onto the following tasks/projects for the last few weeks, which should carry over into the rest of October.

1. Pivoted away from learning Clojure.

A few weeks back I took some time to look at the jobs available for learning Clojure in the Los Angeles area, more as a curiosity than anything. I basically found no jobs for that specific technology. Because of that, I dug into the technology as a whole, and realized that its very niche. Stack Overflow's yearly dev survey put it below 2% of respondents.

Because of this, I stopped my learnings of the language, as not only would it be far fetched to get good enough to actually use it day to day, it would be nearly useless in regards to future possible job opportunities.

Instead, I've started reviewing topics "closer to home", so I've been reading older docs on Reactive programming with rxjs.

1. Starting to seriously work on the final iteration of my "main side-project"

My main side-project is essentially a flash card app. Which was only slightly more interesting than a TODO-app. However, I've been paying for its domain for a year+. Its not much (12$ a year), but I realized I should get something up on the domain and call it "finished". Because of this I've started working on what is now the 5th iteration of the project with the pure goal of finishing it with bare-bones functionality.

I'll be spending most of my extra development energy on this project, and I've been keeping track of my work using toggl.io to see how "quick" I actually did it.

1. Hacktoberfest has started, and I've been looking for open source projects to contribute too

I personally like the idea of hacktoberfest. If anything it forces one to "get out of their comfort zone" and contributing to open source. I've been working on a project for someone who has helped me in the past. Which I think is a nice way to learn something new, while "giving back" directly. I'd like to find at least 1 other open source repo to contribute to before months end and will be looking around after I finish up the ones currently on-going.

1. Continue updates on this portfolio/blog

This site has been more "off to the side" in regards to recent updates. There are still a good amount of smaller things, and improvements I need to make, but they will come in time.

Thats all the updates I have for now, keep building, keep learning!

I'm back going over the same side project I've been iterating against. With the main driving force being I'm still paying for the domain name.

Its a simple flash-card app, except this time I'm purposely building it with the goal of finishing it. This means limiting the amount of ops by using firebase, keeping the requirements as simple as possible, and leaning on the technologies I know the most.

It also means the features of the app are going to be limited to the simplest aspects, and I wont optimize much, if anything until the basics are working.

Essentially the core requirements are the "proof of concept" level, and there isn't anything beyond that. So I should be able to focus on actually finishing it.

I already started the project, using the nx-template-workspace repo as a starting point, and this week spent a few hours setting up some re-usable ngrx.

The ngrx code still need some work, as I realized I could refactor it to support dead code elimination, which would allow it to be moved to the nx-template-workspace so it could be used for future projects.

Finally, I started re-using toggl to track my time, so I can keep a rough idea of how much time I'm spending on this project overall. I've been using this system to keep track of actual work, and side project work, more to get an idea of how toggl works, and possibly get some metrics on how much I'm working overall.

Hopefully I'll stick with this project until it gets into a usable state. All the previous 4 versions got decently far (roughly 30%) before I abandoned them, but all in all I did learn something with each iteration, and so far the latest one is no different.

I realized the last actual time off I took was before the pandemic, which might explain why I've been feeling rather burnt out as of late. I did take off 2 days since then, but 1 of those was for moving.

Because of all this I finally took a last minute day off before the labor day weekend to help recoup. I'll probably be spending it learning more about clojure, or just taking it easy beyond tending to some personal things. Hopefully by next week I'll be feeling much more energized!

I've finally gotten around to updating this blog/portfolio site with updates to the "list" pages. The list pages are the pages used to list the blog, snippets, apps, and project posts.

From the "end-user side" the update added the following:

• fuzzy text searching searching via fuse.js
• sorting by created-date and title
• tag filtering

Together it should be easier to find more interesting topics over time.

I just recently fixed some issues that was breaking the actual loading of these pages (really need to get around to adding som e2e tests), but otherwise the above features should more or less be available now.

On the "dev-side" I was able to try out more of storybook to see what its all about. I don't think the 1 component I created with storybook is the "model example" of how you can leverage storybook, but it was at least a great learning experience.