Forem: Greg Hamilton

What is state and why is it so important in UI development?

Greg Hamilton — Thu, 01 May 2025 06:57:47 +0000

What is State and Why is it So Important in UI Development?

Hello there, eager learner! 🌟 Today, we’re going to dive into an exciting concept in computer science that will help you understand how applications work behind the scenes. This concept is called state. You might wonder, what is state? Why does it matter? Don’t worry! We’ll break it down together in a fun and simple way. Let’s get started!

🤔 What is State?

At its core, state is just a fancy word for storing information. Think of it like a box where you keep your toys. When you want to play, you open the box to see what’s inside. In the world of computers, the state holds data that your program needs to keep track of.

For example, let’s consider a simple game where you collect points. Your score (the number of points you have) is the state of the game at any given time. If you collect more points, the state changes!

Examples of State in Action

Let’s look at a few examples to make it clearer:

Shopping Cart: In an online store, when you add items to your cart, the list of those items is the state. When you remove something, the state updates to reflect that change.
Toggle Switch: Think about a light switch that can either be on or off. The position of the switch represents its state: on or off.

🎨 Why is State Important in UI Development?

Now, you might be wondering why we need to worry about state when creating user interfaces (UI). Well, the state is crucial because it affects how users interact with the application. A well-managed state ensures that users have a clean and seamless experience. Here’s why it’s important:

User Experience: If a user clicks a button, you want something to happen right away! The state of your app changes based on user actions, allowing for instant feedback.
Consistency: When the state is managed properly, users can trust that their choices will be remembered. For example, if a user fills out a form and accidentally refreshes the page, a good state management would save their inputs so they don’t lose their progress.
Efficiency: Managing state efficiently helps in improving the performance of your application. By updating only the parts of your UI that need to change, your app can run smoother and faster.

🛠 How to Manage State

In UI development, we often use different tools and techniques to manage state. Here are some beginner-friendly options:

Variables: These are like labeled boxes. You can store information in them, and whenever you need that info, you just look inside the box.
Arrays: This is like a special box that holds a list of items. For example, in a shopping cart, you can have an array containing all the items selected by the user.
State Management Libraries: For more complex applications, developers use tools like Redux or Context API in React. These libraries help track and manage state across different parts of the application.

Here is a simple example in a fictional UI to illustrate state:

let score = 0; // This variable stores the score (state)

// Function to update score
function collectPoints(points) {
  score += points; // Changes state when points are collected
  console.log("Current Score:", score); // Displays the updated score
}

// Simulate collecting points
collectPoints(5); // Current Score: 5
collectPoints(3); // Current Score: 8

In this example, the score variable represents the current state. The collectPoints function updates this state whenever the user collects points.

🔍 Real Life Example

Let’s say you’re using a weather app. The state of that app might include:

Current temperature (e.g., 75°F)
Weather condition (e.g., sunny)
Location (e.g., New York)

When you change the location in the app, the state updates to reflect the new weather information for that city.

let weatherState = {
  temperature: 75,
  condition: "Sunny",
  location: "New York"
};

// Function to change location and update weather
function updateWeather(newLocation, newTemperature, newCondition) {
  weatherState.location = newLocation;
  weatherState.temperature = newTemperature;
  weatherState.condition = newCondition;
  console.log(weatherState);
}

// Updating weather state
updateWeather("Los Angeles", 85, "Clear");

💬 A Common Interview Question

Question: What is state, and why is it important in web apps?

Perfect Answer: State is a way to store information in an application, which keeps track of changes over time. It’s essential because it allows an application to respond effectively to user interactions, ensuring a smooth and consistent user experience.

💡 Quick Quiz

What is an example of state in a simple application?
Why is managing state important for user experience?
Name one tool or method to manage state in UI development.

🔥 Pro Tip

If you’re curious about more advanced techniques, consider exploring state management libraries like Redux or MobX! They help manage state in larger applications where the state can become tricky to handle.

📚 Extra Refresh

✅ Quick Quiz Answers

An example of state could be the score in a game or items in a shopping cart.
Managing state is important for user experience because it ensures the application behaves predictably and remembers user interactions.
One tool to manage state is to use variables, arrays, or libraries like Redux.

Happy learning, and keep exploring the fascinating world of computer science! 🎉

🙏 Thanks for reading!

Enjoy this article? Check out my other articles on my blog and please hit the ❤️ button to help others find it.

Still got questions? Leave a comment below and I'll do my best to answer them.

What is memory when we talk about computers?

Greg Hamilton — Wed, 30 Apr 2025 07:43:09 +0000

What is memory when we talk about computers?

When we talk about computers, we often hear the term "memory." But what exactly does that mean? Imagine your brain, where you store your thoughts, ideas, and everything you know. Your brain has a limited amount of space—just like a computer has memory! Let’s dive deep into this topic to understand what memory is, how it works, and why it's essential for computers.

🧠 What is Computer Memory?

Computer memory is like a container that stores information temporarily or permanently. It's where data is held so that the computer can quickly access it when needed. There are two main types of memory:

RAM (Random Access Memory): Think of RAM as your short-term memory. It stores information that your computer is currently using or processing. When you close a program, any data that was only in the RAM disappears, just like you might forget a phone number once you’re done using it.
ROM (Read Only Memory): This is like your long-term memory. ROM holds important information that doesn’t change, like the instructions needed to start up your computer. Even if you turn off the computer, the data in ROM remains safe—like a diary that you keep safely on a shelf.

📦 Why is Memory Important?

Without memory, a computer wouldn’t be able to function properly. When you open a program, the computer needs to store that program in memory to run it efficiently. If there isn't enough memory, the computer may slow down or struggle to work correctly.

How Does Memory Work?

Memory components can be compared to different areas of a house:

RAM is like a workbench in your garage. It's a place where you can quickly access the tools and materials you need for a project.
ROM is like a bookshelf with important reference books. You need the information sometimes, but you don't use it every day, so it’s stored away neatly.

When you want to use a program, your computer takes it from the hard drive (a different type of storage) and loads it into RAM. This loading process is fast, making it quick to use the program. After you finish, anything not saved will disappear when the computer turns off.

📊 Different Types of Memory

Besides RAM and ROM, there are other types of memory in computers:

Cache Memory: This is like a super-fast snack station in your kitchen. It holds copies of the data that the computer works with most often, making it quicker to access.
Storage Memory: This includes hard drives (HDD) and solid-state drives (SSD). Think of these as your attic or basement, where you store everything long-term.

Example of Using Memory in Coding

When we write a simple program, we declare variables to store data temporarily. These variables use RAM for quick access. Here’s an example in Python:

# Storing a number in a variable
age = 5  # This uses RAM to hold the value '5'
print("I am", age, "years old!")

In this code, the variable age temporarily holds the value 5 while running the program.

🔍 Real Life Example

Imagine you are constructing a Lego house. The workspace where you build is like RAM because you can quickly and easily reach the pieces you’re currently using. The box you keep your extra Legos in is like your hard drive, where stored data is kept but accessed slower than from your workspace.

💬 A Common Interview Question

Question: What is the difference between RAM and ROM?

Perfect Answer: RAM, or Random Access Memory, is a type of temporary memory that stores data the computer is currently using. It's fast and used for quick access. When the computer is turned off, everything in RAM is lost. On the other hand, ROM, or Read Only Memory, is a permanent type of memory that contains important instructions for booting the computer and is not erased when the computer is turned off.

💡 Quick Quiz

What kind of memory is used for temporary storage while a computer is on?
What does ROM stand for, and why is it important?
In the Lego analogy, what role does the workspace play compared to the box?

🔥 Pro Tip

For those interested in diving deeper, understanding how virtual memory works can be a great next step. Virtual memory allows your computer to use hard drive space to act as additional RAM, helping it run more applications than the physical RAM would otherwise permit.

📚 Extra Refresh

✅ Quick Quiz Answers

RAM is used for temporary storage while a computer is on.
ROM stands for Read Only Memory, and it is important because it stores permanent instructions for booting the computer.
In the Lego analogy, the workspace plays the role of RAM, and the box plays the role of the hard drive.

What are APIs and why are they everywhere?

Greg Hamilton — Tue, 29 Apr 2025 14:36:29 +0000

What are APIs and why are they everywhere?

Imagine you are in a restaurant. You are super hungry, but instead of going into the kitchen to cook your food, you sit at a table and order from a menu. A friendly waiter takes your order and brings your food to you. In this analogy, the waiter is like an API (Application Programming Interface).

APIs help different pieces of software talk to each other, allowing them to work together smoothly. Let’s dive deeper into what APIs are, how they work, and why they are such a big deal in today’s tech world!

📦 What is an API?

An API is a set of rules that lets different computer programs communicate with each other. It lets one program ask another program for information or actions without having to know how the other program works under the hood.

Think of it like a vending machine. You press a button for your favorite snack, and without knowing the machine’s inner workings, you receive your treat. The API defines how you can interact with the machine (or the program).

Frontend and Backend

Before we go further, let’s clarify two terms: frontend and backend.

Frontend: This is the part of a software application that users interact with. It’s what you see on your screen, like buttons and menus.
Backend: This is the behind-the-scenes part of an application. It doesn’t have a user interface; it’s where all the heavy lifting happens, like data management and business logic.

APIs bridge the gap between the frontend (what you see) and the backend (what happens behind the scenes).

🤔 How do APIs work?

When you use an app that needs to get or send data — like checking the weather, for instance — here’s what happens:

You make a request: You click a button or type something in the app (like "What's the weather today?").
The app sends your request to the API: The app formats your request in a way that the API understands.
The API talks to the backend: The API sends your request to the backend, which processes it and gets the necessary data.
The API sends the response back: Once the backend has the data (like the current weather), the API formats that data and sends it back to your app.
The app shows it to you: Finally, the app displays the weather information on your screen.

Here’s a simplified example:

fetch('https://api.weather.com/v3/wx/conditions/current?apiKey=YOUR_API_KEY')
  .then(response => response.json())
  .then(data => console.log(data));

In this code snippet, fetch() is a function that makes a request to the weather API. It gets the current weather conditions in a format that the app can understand.

🌍 Why are APIs Everywhere?

APIs are like the glue that holds different software pieces together. Here are a few reasons why APIs are everywhere:

Integration: They allow different tools and services to work together. For instance, when you share something on social media from an app, that app uses an API to connect with the social media site.
Accessibility: APIs make it easy for developers to access powerful functionalities without building everything from scratch. Think of trying to build a car from just metal and wheels. Instead of doing that, you can use existing tools (like APIs!) to build a much better application.
Innovation: With APIs available, developers can quickly create new applications by combining existing services, which enables rapid innovation.
Data sharing: APIs make it possible to take data from one place and use it in another, leading to smarter applications that can provide better user experiences.

🔍 Real Life Example

Consider a restaurant website:

Frontend: The menu you see on the website.
Backend: The kitchen where the food is prepared and orders are processed.
API: The server that takes your order and communicates between the frontend and backend.

When you click “Add to Cart,” the frontend calls the API to tell the backend what food you want.

const addToCart = async (item) => {
  const response = await fetch('https://restaurant.com/api/cart', {
    method: 'POST',
    body: JSON.stringify(item),
    headers: {
      'Content-Type': 'application/json'
    }
  });
  return response.json();
};

Here, the function addToCart sends your food choice to the linking API.

💬 A Common Interview Question

Question: What is an API, and why is it important?

Perfect Answer: An API, or Application Programming Interface, is a set of protocols and tools that allows different software applications to communicate with each other. It acts as a bridge between the frontend and backend, enabling smooth data transfer and functionality integration. APIs are important because they facilitate the connection between different services, enhance user experiences, and allow developers to build applications faster by leveraging existing functionalities.

💡 Quick Quiz

What does API stand for?
What are the two main components of a software application discussed in this article?
Why are APIs considered essential in modern software development?

🔥 Pro Tip

When working with APIs, always check the official documentation. Each API has its own set of rules and requirements, and understanding these will help you use them effectively.

📚 Extra Refresh

✅ Quick Quiz Answers

Application Programming Interface.
Frontend and Backend.
APIs allow different applications to communicate, integrate services, and enhance user experiences.

Still got questions? Drop them in the comments below and I'll do my best to answer them :)

Why Do LLMs Need GPUs? Here's What I Found Out

Greg Hamilton — Tue, 29 Apr 2025 12:32:57 +0000

Lately, I've been seeing a lot of headlines about how the latest GPUs are unlocking crazy new capabilities for AI. Things like GPT-4, text-to-video models, and even real-time AI-powered gaming characters. Everywhere I looked, there was talk about how important GPUs are - but if you're like me, you might be wondering: why are GPUs such a big deal for AI in the first place?

I'll be honest: when I first heard "GPU," my mind immediately went to gaming - powerful graphics cards that help run beautiful 3D worlds. What I didn't realize until recently is that GPUs are just as important (if not more so) in the world of AI.

I did a little digging, and in this post, I'm going to share what I learned - explained the way I wish someone had explained it to me.

CPUs vs GPUs: The Speed vs Specialization Trade-off

First, let's talk about what a GPU actually is, and how it's different from the CPU (the regular brain of your computer).

CPUs (Central Processing Units) are designed for general-purpose tasks. They're great at doing a wide variety of things, one (or a few) at a time, very quickly and flexibly.
GPUs (Graphics Processing Units) are designed for highly specialized tasks - originally rendering images by doing the same type of math operation thousands or millions of times in parallel.

Imagine you had to solve a giant pile of math problems. A CPU is like hiring one genius mathematician who can solve any problem, one by one. A GPU is like hiring an army of thousands of good mathematicians who can each handle a problem at the same time.

Now, here's where it clicked for me: training and running an AI model - like a Large Language Model (LLM) - is less like solving a single huge problem and more like solving millions of small ones at the same time.

The Math Behind AI Models (It's Simpler Than You Think)

At its core, AI - especially deep learning - is really just lots and lots of matrix math.

(If you've ever seen those arrays of numbers in school, that's what matrices are.)

An LLM like GPT-4 or Claude processes information by taking input (like words), turning them into numbers (embeddings), and then applying a bunch of matrix operations over and over to make predictions about what should come next.

These operations include things like:

Multiplying huge matrices
Adding numbers together
Applying simple functions (like ReLU, softmax, etc.) across many values at once

All of these tasks happen millions or even billions of times during a single training run.

Matrix operations are:

Predictable
Repetitive
Embarrassingly parallel (meaning they can be split up and done at the same time without causing problems)

And that's exactly what GPUs were born to do.

Why GPUs are Perfect for AI

When I realized this, it made perfect sense why GPUs have become the foundation of AI. Here's what they bring to the table:

Thousands of cores
➔ They can process tons of small calculations at once.

High memory bandwidth
➔ They can move huge amounts of data around very quickly.

Specialized tensor cores (on modern GPUs)
➔ Extra hardware specifically optimized for matrix operations, which AI uses constantly.

In short: the same things that made GPUs good for rendering beautiful video games also make them insanely good for training AI models.

But even more interesting - companies like NVIDIA, AMD, and others have now purpose-built their newest GPUs (like the NVIDIA H100) specifically with AI in mind. They're no longer just for gamers; they're AI powerhouses.

What Happens Without GPUs?

I found it wild to learn that without GPUs (or other specialized accelerators like TPUs), training a cutting-edge AI model would be almost impossible.

Training GPT-3, for example, reportedly took thousands of GPUs running for months non-stop.
Without GPUs, it would have taken hundreds of years on regular CPUs to train the same model.

Even running an AI model at scale (what's called "inference") can be painfully slow without GPUs - and in a world where users expect instant responses from their AI assistants, speed is everything.

So… Could the Future Be Even Faster?

One thing that got me super excited is that GPU technology is still improving fast.

Every year, newer GPUs are:

More powerful
More energy-efficient
More specialized for AI workloads

And companies are even developing completely new kinds of hardware (like tensor processing units, AI accelerators, and even optical computing) to make things even faster.

In other words: the amazing AI tools we're seeing today are just the beginning - and the hardware race behind the scenes is fueling it all.

Final Thoughts

At the start of this journey, I thought GPUs were just something gamers cared about. Now, I see that they're absolutely vital to AI.

If CPUs are like versatile chefs who can cook anything, GPUs are like pizza shops that can churn out 1,000 perfect pizzas an hour. And in the world of AI, we don't need fancy meals - we need a whole lot of perfect pizzas, fast.

I hope this explanation helped you the way it helped me. If you're just starting to learn about AI like I am, it's incredible how much of it boils down to simple ideas - just operating at mind-blowing scales.

I'm still new to the AI world, so if you've got tips, corrections, or cool resources to share, I'd love to hear from you in the comments! Let's learn together. 🚀

Thoughts on Vibe Coding — and What That Means for All of Us

Greg Hamilton — Mon, 21 Apr 2025 16:12:57 +0000

If you’ve been anywhere near the tech press lately, you’ve probably heard the term “vibe coding.” My news feed is full of it. It’s one of those phrases that started as a joke but now seems to be everywhere. As someone who’s self-taught, and someone who now teach others how to code, I’ve been watching this trend with a mix of fascination and unease. What does it mean when anyone can build an app just by chatting to Cursor? How will this affect my job and the wider industry in general? Is this the death of ‘traditional’ software engineering — or just its next evolution? Do established companies even hire vibe coders? Questions…

What Is Vibe Coding?

Coined by OpenAI co-founder Andrej Karpathy in early 2025, “vibe coding” refers to the practice of using AI tools — like large language models (LLMs) — to generate code based on natural language prompts. Instead of writing code line by line, you describe what you want, and the AI builds it for you. Karpathy described it as “fully giving in to the vibes,” where you interact with the AI using voice or text, letting it handle the implementation details.

But here’s the thing… Andrej Karpathy understands how code works. What causes my eyebrow to assume a slightly less than horizontal attitude is when I read statements like this:

In vibe coding, the coder doesn’t need to understand how or why the code works and often accepts that a certain number of bugs and glitches will be present.

🤨 Hmm. But let’s set that aside for now.

The Growth of Vibe Coding

The adoption of vibe coding has been nothing short of explosive. According to Business Insider, a quarter of startups in Y Combinator’s current cohort have codebases that are almost entirely AI-generated. A quarter! Let that sink in a moment. OK, well that’s startups. Fair enough. But wait, there’s more… Google CEO Sundar Pichai reported that AI systems now generate a quarter of new code for the company’s products.

Startups like Lovable and Windsurf are offering lucrative salaries for “vibe coder–AI engineers,” emphasizing tools over degrees . Companies like DV8 Infosystems are hiring based on mindset and AI tool fluency — not formal education.

As a Self-Taught Developer, I’m Torn

I didn’t go through a formal CS program. I learned by building things, breaking them, Googling my way through bugs, reading, watching hundreds of hours of teaching and banging my head against a wall at 2am shouting things like: “Why won’t you work!!??”. So in theory, vibe coding should feel like a win — more access, an easy life, fewer gatekeepers. But I can’t help but worry.

If AI can build 80% of an app from a prompt, where does that leave developers like me? Are we being replaced — or just redefined? And what happens to the craft of software engineering when the barrier to entry drops so dramatically (if indeed it is actually dropping)?

The Reported Pros and Cons of Vibe Coding

Pros:

Speed: Vibe coding can accelerate development, allowing for rapid prototyping and iteration.
Accessibility: It lowers the barrier to entry, enabling non-developers to create functional software. Interesting question: If I can create software am I really a non-developer?
Innovation: By automating routine tasks, developers can focus on higher-level design and problem-solving.

Cons:

Quality and Maintenance: AI-generated code may lack the robustness and clarity of human-written code, leading to maintenance challenges.
Security Risks: Without proper oversight, AI-generated code can introduce vulnerabilities.
Skill Atrophy: Relying heavily on AI tools may erode fundamental coding skills over time.

I tried it!

I couldn’t shake the feeling of being torn, so I decided to just jump in and give it a go. I’ve got a fair bit of experience with web and mobile development, so I decided to try something I have very little experience with, but something that I’ve always wanted to have another go at:- building a game. As it happens, I’d just read an interesting article on vibe coding a game; which of course made it sound super easy — all the tools one could leverage and how just a few prompts would turn me into an indie triple A studio. Sweet. The challenge was on.

So “what is this game?”, I can hear you wondering. Where can I check it out? Well I’m sorry to disappoint but it’s still in development. You see, I didn’t want a simple 2D game of Pong. I wanted to try to build an idea that I actually had, and an idea I actually liked — a ‘real world’ use case. Nothing rediculous like a 3D multi-player FPS. Just a simple 2D game that looks isometric, a bit like Stardew Valley — that mega popular farming game everyone loves. It turns out that it’s not so easy. Assets aside, I found that my cutting edge AI-enabled IDE struggled immensely with the task. There were times where it wrote multiple files and left me jumping for joy. Then there were times where it just went round in a loop, getting stuck, changing the code, guessing over and over again and returning to the same point 100 edits later with the same unsolved issue. Immensely frustrating!

So here we are back again… on the fence. So much promise, tempered with so much frustration. If I wasn’t able to engineer my own solutions to those problems — how long would I be stuck beating my head against the wall? Could I try again tomorrow and get a better answer from AI? At the rate things are developing… probably!

Are Vibe Coders Getting Hired?

Yes, and at impressive rates. Companies are actively hiring vibe coders, with some roles paying up to $200K. The demand is growing, and the definition of a “technical founder” is evolving. Investors are now valuing domain expertise and the ability to leverage AI tools over traditional coding skills.

However, this trend also raises questions about the long-term implications for software engineering as a profession. While vibe coding opens doors for many, it also challenges the traditional pathways and skill sets that have defined the industry to-date.

Final Thoughts

Vibe coding feels to me like more than a trend. In the tech world, we’re used to trends. But this feels like a real shift in how we in the tech industry think about building software. As someone who learned to code through self-study, I see both the opportunities and the challenges it presents. It’s an exciting time, but also one that requires careful consideration of the implications for our industry and our roles within it.

What do you think? Is vibe coding the future of software development, or just a passing phase? Worried about Vibe Coders flooding the job market? I’d love to hear your thoughts in the comments below.

I Built a Tool That Documents Your Code For You — Here's Why (and How)

Greg Hamilton — Wed, 09 Apr 2025 12:25:01 +0000

Hi Devs! 👋 I recently launched DocBlitz, a SaaS tool that auto-generates cloud documentation for your codebase and keeps it in sync — with AI-powered search and chat built-in. This post is a quick peek at why I built it, what I learned, and how I hope it helps others.

The Problem That Sparked It 💡

Like many developers, I’ve worked on projects with outdated, missing, or scattered documentation. It’s frustrating — for the dev team, for product managers, for support staff. And I’m not alone.

In fact, a 2021 GitHub Open Source Survey found that 93% of developers say incomplete or outdated documentation is a pervasive problem.

For early-stage startups or indie projects, it’s even worse:

Docs often fall behind or never get written.
Different developers write in different styles with different levels of quality.
Teams forget how things work.
New hires ask the same questions.
Non-technical teammates feel lost.

I kept thinking: why doesn’t documentation just generate itself… and stay up to date?

The Solution I Built 🛠️

I built DocBlitz to solve that. It:

Scans your connected repo(s) and generates a full-featured documentation site — in minutes.
Keeps your docs in sync as your code changes.
Lets anyone “chat with your docs”, using an AI-powered interface that understands your code.

It’s designed for small dev teams, startups, development agencies and solo devs who don’t have time to write (or maintain) docs but want something that looks and works great.

Here's a sneak peek at the output (a pretty docsite for a NetFlix clone I built while learning Next.js) 👇

🧠 What I Learned Along the Way

Building DocBlitz has taught me a lot.

I began the project with only a minimal understanding of AI technologies and almost no practical experience in building AI applications, so this was a significant personal challenge.

A few key takeaways:

LLMs don’t “understand” language the way humans do — they predict it

Large Language Models are trained to guess the next word in a sentence based on patterns in massive amounts of text data. It’s like a supercharged version of autocomplete. What’s wild is that by just learning to predict the next word really well, LLMs end up being able to write essays, debug code, translate languages, answer questions, and more—even though they don’t truly “know” anything. But if they don't “know” anything, how can they document an entire codebase, where every minor detail matters and there's no room for mistakes or guesses? Well, it turns out that LLMs are actually really good at this!

Through a combination of pattern recognition, token prediction, context (more on that below) and self-attention, LLMs can identify structure, infer intent, and generate documentation that feels surprisingly accurate—even for unfamiliar code. They’ve effectively “read” millions of codebases and documentation styles, so when they see a new function or class, they can often recognise patterns and produce descriptions that mirror what a human would write. They pick up on naming conventions, logic flow, and relationships between files and components, and use that to generate contextually relevant explanations.

This blew my mind the first time I tried it. A few lines of code in, and the LLM was already writing documentation that I would’ve otherwise spent hours drafting myself. Of course, it’s not perfect—LLMs still need guardrails, and human review is essential, especially for edge cases. But used thoughtfully, they unlock a new kind of development workflow: one where you can go from raw code to a polished, browsable documentation site in minutes, not days.

That’s the magic DocBlitz is built on.

Perseverance pays off

When it comes to understanding an entire codebase, across multiple repositories, context is a real problem. I noticed that even Cursor and VS Code struggled with this. They only ever 'see' a narrow area of context, which changes frequently as it doesn't remain in memory, and neither editor was able to connect the dots seamlessly between my separate front-end and back-end repos.

I was stuck for weeks on this, spending a small fortune on LLM tokens. I honestly came close to giving up. Thankfully though, I did have a breakthrough. It required designing a whole new system to parse and ultimately 'understand' the relationships and functionality between and within the project's directories and files.

You can imagine my delight when I ran a test on my new system and it worked! #staystrong

The power of queues

In designing the system behind DocBlitz, I realised there were many potential bottlenecks.

For example, an API rate limit on an LLM call. I'd frequently hit the limit as the app tries to process an absolutely massive amount of data in the shortest possible time. So what happens when I get an error code back rather than the response I need to move on. How could I handle this gracefully and ideally, retry this job later?

This is where queues come in. Queue based architecture is perfect here because whenever my app hits the rate limit on an API call now, I can simply add the job to a queue. My queue manager uses a cron job to pull tasks down from the queue at any interval I choose, and attempt to process it again. If it succeeds this time, it comes off the queue. If it fails again, it simply goes back into the queue. Nice!

What Makes DocBlitz Different?

There are some great tools out there — Docusaurus, GitBook, ReadMe — but I wanted documentation that:

✅ Writes itself

✅ Stays updated automatically

✅ Feels modern (think AI chat + full-text search)

✅ Works for both devs and non-dev teammates

✅ Deploys instantly to a hosted cloud docsite

Launching Today 🚀 (Free for Early Users!)

I’m launching the public beta now, and I’d love feedback from real devs using it on real projects.

👉 Try it today at DocBlitz.io

Works with GitHub. I'm giving away a free month (and maybe longer) for early adopters who are happy to provide feedback. Drop me a line at greg@docblitz.io for your free access code.

If you’ve ever struggled with documentation, I’d love to hear from you — comment below or DM me.

Thanks for reading! ✨

P.S. If you're a Dev.to writer or content creator curious to try it out or review it, let’s chat! I’d love to offer you early access.