<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ojo Faith on Medium]]></title>
        <description><![CDATA[Stories by Ojo Faith on Medium]]></description>
        <link>https://medium.com/@ojofaith?source=rss-579dc340d6bf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Fj2Nr1Y5tbOaidMTdh4vqQ.png</url>
            <title>Stories by Ojo Faith on Medium</title>
            <link>https://medium.com/@ojofaith?source=rss-579dc340d6bf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 05:22:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ojofaith/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[A font can change how a message feels, so can a color.]]></title>
            <link>https://medium.com/@ojofaith/a-font-can-change-how-a-message-feels-so-can-a-color-f2d1fef2fce9?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2d1fef2fce9</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 11:39:29 GMT</pubDate>
            <atom:updated>2026-11-13T11:39:29.503Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*34qSlyDvFsCfEN902EquAQ.png" /></figure><p>Likewise a product can work perfectly and still feel poorly designed, Typography is not just about choosing beautiful fonts, it about readability, emphasis and guiding attention.</p><p>Color in the other hand is not just about making a design attractive. it communicates emotions, creates moods and influences how people experiences a product.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xWV5lReedhlDicSevEs8bg.png" /></figure><p>As a someone who design and build product, especially building with A. i am beginning to appreciate something.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OvQaCM2fOELLshtj2HQBwQ.png" /></figure><p>AI can help you write the code, generate the interfaces, and build product faster but you still need design taste to judge what looks right, what feels right and what actually makes sense for the person using it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jn0ejHh4ZqjJvEfGpIB5sQ.png" /></figure><p>Building and designing with AI is one thing, knowing what good looks like is another thing.</p><p><a href="https://www.facebook.com/hashtag/productdesign?__cft__[0]=AZhjjdROu_s_qtYTXaIO8zegTn-0XcmUgxVpCPHH4EExXDtLHvkM_4MTs8u_HfJtdRFweHQ7SnS78wTDi39u3zc8qzB_S5acG8sFSnCJAu_fVNle7mibrzQIYdgw_-89decxgY1d5jpx4xmqKe03zrm9uaE8SpzV9FrZN1Oxxv88aCAAuayfA2eNC9DtBdM&amp;__tn__=*NK-R">#productdesign</a> <a href="https://www.facebook.com/hashtag/productengineering?__cft__[0]=AZhjjdROu_s_qtYTXaIO8zegTn-0XcmUgxVpCPHH4EExXDtLHvkM_4MTs8u_HfJtdRFweHQ7SnS78wTDi39u3zc8qzB_S5acG8sFSnCJAu_fVNle7mibrzQIYdgw_-89decxgY1d5jpx4xmqKe03zrm9uaE8SpzV9FrZN1Oxxv88aCAAuayfA2eNC9DtBdM&amp;__tn__=*NK-R">#productEngineering</a> <a href="https://www.facebook.com/hashtag/aitools?__cft__[0]=AZhjjdROu_s_qtYTXaIO8zegTn-0XcmUgxVpCPHH4EExXDtLHvkM_4MTs8u_HfJtdRFweHQ7SnS78wTDi39u3zc8qzB_S5acG8sFSnCJAu_fVNle7mibrzQIYdgw_-89decxgY1d5jpx4xmqKe03zrm9uaE8SpzV9FrZN1Oxxv88aCAAuayfA2eNC9DtBdM&amp;__tn__=*NK-R">#AITools</a> <a href="https://www.facebook.com/hashtag/typography?__cft__[0]=AZhjjdROu_s_qtYTXaIO8zegTn-0XcmUgxVpCPHH4EExXDtLHvkM_4MTs8u_HfJtdRFweHQ7SnS78wTDi39u3zc8qzB_S5acG8sFSnCJAu_fVNle7mibrzQIYdgw_-89decxgY1d5jpx4xmqKe03zrm9uaE8SpzV9FrZN1Oxxv88aCAAuayfA2eNC9DtBdM&amp;__tn__=*NK-R">#Typography</a> <a href="https://www.facebook.com/hashtag/visualdesigner?__cft__[0]=AZhjjdROu_s_qtYTXaIO8zegTn-0XcmUgxVpCPHH4EExXDtLHvkM_4MTs8u_HfJtdRFweHQ7SnS78wTDi39u3zc8qzB_S5acG8sFSnCJAu_fVNle7mibrzQIYdgw_-89decxgY1d5jpx4xmqKe03zrm9uaE8SpzV9FrZN1Oxxv88aCAAuayfA2eNC9DtBdM&amp;__tn__=*NK-R">#visualdesigner</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2d1fef2fce9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My first step away from been shy]]></title>
            <link>https://medium.com/@ojofaith/my-first-step-away-from-been-shy-bc203ce18cd8?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc203ce18cd8</guid>
            <category><![CDATA[ideas]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Sat, 17 Oct 2026 12:48:08 GMT</pubDate>
            <atom:updated>2026-10-17T12:48:08.963Z</atom:updated>
            <content:encoded><![CDATA[<p>I have always been the shy one. In class, in rooms, in meetings, I would rather build the thing quietly than stand up and talk about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tkDGavht8zDftvkz8wwk_A.png" /><figcaption>This week I stood up and talked about it.</figcaption></figure><p>I spoke at the Dev &amp; Design workshop on Agentic Software Engineering, and my session was on the head of a web page. Most people spend their time on the body, the header, the sections, the footer. The head is the part nobody looks at, and it decides how your page appears when someone shares the link. I also ran a live session on making the head dynamic, so that every page gets its own title, description and preview instead of one fixed set for the whole site.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UQbfG5a_5ie52QypGZAd2A.jpeg" /></figure><p>The hardest part was not the talk itself. It was clicking register. I had to bet on myself before I felt ready, and I did not feel ready.</p><p>The second hard part was preparing. I thought I understood the topic well. Then I tried to explain it step by step, and I found the places where I only half knew it. Understanding something in your own head is comfortable. Explaining it to people who are listening closely is not, and it shows you very quickly what you really know.</p><p>Three things stayed with me:</p><ol><li>Being ready is rarely a feeling. I signed up while nervous, and the readiness came from preparing, not from waiting.</li><li>Teaching exposes your gaps faster than any course. I understand the head of a page better today than I did a week ago.</li><li>Shy does not mean unable. It only means the first step costs more.</li></ol><p>I am a designer moving toward engineering, and I am still learning every day. This week showed me that sharing what I learn is part of learning it.</p><p>If you are sitting on something you know well and have never said out loud, say it somewhere this week. A small room is enough.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc203ce18cd8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a Circuit Breaker Works: Stopping One Failure From Becoming Many]]></title>
            <link>https://medium.com/@ojofaith/how-a-circuit-breaker-works-stopping-one-failure-from-becoming-many-4d28b9edb1dc?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d28b9edb1dc</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 07:55:25 GMT</pubDate>
            <atom:updated>2026-10-14T07:55:25.604Z</atom:updated>
            <content:encoded><![CDATA[<p>Most products depend on other services. A shop depends on a payment provider. A chat product depends on an AI model. An app depends on a maps service, an email service, and a dozen others. Each of those services will be slow or unavailable at some point, and when that happens, the damage rarely stays where it started.</p><p>A circuit breaker is a small piece of logic that stops that damage from spreading. This article explains the problem it solves, how it works, and the decisions you have to make when you add one.</p><h3>The problem: one slow service can take down everything</h3><p>Imagine a checkout page that asks a recommendation service for “you may also like” items. The recommendation service starts to struggle and takes thirty seconds to answer instead of one.</p><p>Here is what happens next, and why it gets worse instead of better.</p><ol><li>Each checkout request now waits thirty seconds for the recommendation service.</li><li>While they wait, those requests keep using memory and connections on your server.</li><li>New requests arrive faster than old ones finish, so waiting requests pile up.</li><li>Your server runs out of room, and it slows down for everything, including parts that have nothing to do with recommendations.</li><li>The services that call your server begin to wait too, and the problem moves up the chain.</li></ol><p>This is called a cascading failure. A side feature has become a reason the whole product stops working.</p><p>Retries make it worse. When a request fails, the natural reaction is to try again. If every caller retries a struggling service, the service receives even more traffic at the exact moment it cannot cope, and it stays down longer.</p><h3>The idea</h3><p>The name comes from the electrical box in a building. When too much current flows, the breaker trips and cuts the connection, so the wiring does not overheat. Later, someone resets it.</p><p>The software version works the same way. You place a wrapper around calls to another service. The wrapper watches how those calls are going. If too many fail, it stops sending calls altogether for a while, and fails immediately instead. This gives the struggling service room to recover and spares your own server from waiting on something that is not going to answer.</p><p>Failing instantly is the key point. A fast, clear failure is much cheaper than a slow one.</p><h3>The three states</h3><p>A circuit breaker is always in one of three states.</p><ul><li><strong>Closed.</strong> Everything is normal. Calls pass through to the other service, and the breaker quietly counts successes and failures.</li><li><strong>Open.</strong> Too many calls have failed. The breaker blocks all calls and returns an error or a fallback immediately, without contacting the other service at all.</li><li><strong>Half-open.</strong> After a waiting period, the breaker lets a small number of test calls through. If they succeed, the service has recovered and the breaker closes again. If they fail, it opens again and the waiting period restarts.</li></ul><p>The path is a loop: closed, then open when trouble appears, then half-open after a pause, then closed again once things recover.</p><h3>A worked example</h3><p>Take the checkout page again, and say the breaker is set to trip when half of the last twenty calls fail, and to wait thirty seconds before testing again.</p><p>The recommendation service begins timing out. After ten failures in twenty calls, the breaker opens. From that moment, the checkout page does not wait for recommendations at all. It simply leaves that section empty, or shows a default list, and the page loads quickly.</p><p>Thirty seconds pass. The breaker moves to half-open and sends one test call. It succeeds, so the breaker sends a few more. They succeed too, so the breaker closes and recommendations return. Nobody had to restart anything, and the customers who were checking out never noticed.</p><h3>What to do while the breaker is open</h3><p>The breaker only stops the calls. You still have to decide what the product does in the meantime. This is called the fallback, and it depends on how important the feature is.</p><ul><li><strong>Show a default.</strong> Popular items instead of personal recommendations.</li><li><strong>Use saved data.</strong> Show the last successful result, if old information is acceptable.</li><li><strong>Hide the feature.</strong> Leave the section out, as in the example above.</li><li><strong>Queue the work.</strong> For tasks like sending an email, store the request and complete it later.</li><li><strong>Show an honest message.</strong> For essential features, tell the user plainly that something is unavailable and when to try again.</li></ul><p>Be careful with saved data. An old list of recommendations is harmless. An old price or an old account balance is not. A fallback must never present something false as if it were true.</p><h3>The decisions you have to make</h3><p>There is no standard setting that suits every service. These are the choices, and each one is a tradeoff.</p><ul><li><strong>What counts as a failure.</strong> Timeouts and server errors usually count. Errors caused by a bad request, such as a missing field, usually should not, because the other service is working fine.</li><li><strong>How sensitive the breaker is.</strong> If it trips too easily, a brief hiccup switches off a feature for no good reason. If it trips too slowly, it gives little protection.</li><li><strong>How long it stays open.</strong> Too short, and it keeps hitting a service that has not recovered. Too long, and a healthy service sits unused.</li><li><strong>How many calls it needs to see first.</strong> A breaker that opens after two failures out of three calls will be wrong often. It needs enough traffic to judge fairly.</li><li><strong>One breaker per dependency.</strong> A single shared breaker means one failing service can switch off calls to healthy ones.</li></ul><h3>Timeouts and retries</h3><p>A circuit breaker is not a replacement for the two things it works alongside.</p><ul><li><strong>Timeouts</strong> are required. Without one, a call can wait forever, and the breaker never sees a failure to count. Set a limit on how long any call may take.</li><li><strong>Retries</strong> are useful for brief, random failures, but only with a growing delay between attempts and a small limit on the number of tries. When the breaker is open, retries should stop completely.</li></ul><p>The three work as a set. The timeout limits how long one call can hurt you, the retry handles small glitches, and the breaker handles sustained trouble.</p><h3>Where this matters for AI products</h3><p>If you build with AI, you depend on a model provider, and model providers have slow periods, rate limits, and outages. A request to a model can take far longer than a normal web request, which makes piled-up waiting requests even more costly.</p><p>A circuit breaker around the model call lets your product respond sensibly when that happens. It could switch to a smaller or alternative model, return a saved answer, or tell the user the assistant is unavailable, instead of leaving them watching a spinner.</p><h3>Costs and limits</h3><p>A circuit breaker is not free, and it does not fix everything.</p><ul><li>It adds a moving part, and moving parts can be misconfigured.</li><li>It can hide a real problem if nobody notices that it is open. You should be alerted whenever a breaker trips, and you should track how often it happens.</li><li>It protects against slow and failing dependencies, not against bugs in your own code.</li><li>Every fallback is extra work to design and test. A breaker with no sensible fallback only turns a slow error into a fast one.</li></ul><h3>What to remember</h3><p>A circuit breaker watches calls to another service, and when too many fail, it stops making them for a while, then tests carefully before resuming. It has three states: closed, open, and half-open. Its value is not in fixing the failing service. It is in making sure that one failing service does not drag your whole product down with it.</p><p>The breaker is the easy part. The harder and more important question is what your product should do when a dependency is gone, and that is worth deciding before the failure happens, not during it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d28b9edb1dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How RAG Works: Giving an AI Model Something to Read Before It Answers]]></title>
            <link>https://medium.com/@ojofaith/how-rag-works-giving-an-ai-model-something-to-read-before-it-answers-cc044989f9ad?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc044989f9ad</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 07:45:46 GMT</pubDate>
            <atom:updated>2026-10-14T07:45:46.286Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/735/1*wfhSDpGg0QLPRxDLOxmJYA.jpeg" /></figure><p>Ask an AI model about your company’s refund policy and it will answer with confidence. The answer may even sound right. The problem is that the model has never seen your policy. It is filling the gap with what refund policies usually say, and that is a guess dressed as a fact.</p><p>RAG exists to fix this. The letters R-A-G stand for retrieval augmented generation, which is an awkward name for a simple idea: before the model answers, find the relevant information and put it in front of the model. This why am writing this article to explains how that works, step by step, and where it tends to break.</p><h3>What problem does RAG solves</h3><p>A language model learns from a large body of text, and then learning stops. That creates three limits that matter when you build a product.</p><ul><li>It has a cutoff. It knows nothing that happened after its training ended.</li><li>It has never seen your private material. Your documents, your customer records, and your internal rules were not part of its training.</li><li>It fills gaps instead of admitting them. When it does not know, it often produces something plausible anyway.</li></ul><p>You could retrain the model on your own material, but that is slow and expensive, and the knowledge goes stale the moment your documents change. RAG takes the opposite approach. It leaves the model alone and changes what the model is shown at the moment of the question.</p><p>The usual comparison is an exam. A normal model sits a closed-book exam and relies on memory. A model using RAG sits an open-book exam, with the right pages placed on the desk before it starts writing.</p><h3>The two stages</h3><p>Every RAG system has two stages. One happens ahead of time, and one happens every time a user asks something.</p><h3>Stage one: preparing the material</h3><p>This is done before any user arrives.</p><ol><li>Collect the documents. These could be policy pages, help articles, contracts, product manuals, or notes.</li><li>Split them into chunks. A long document is cut into smaller pieces, often a few paragraphs each. The model cannot read an entire library for every question, so the system needs pieces small enough to pick from.</li><li>Turn each chunk into an embedding. An embedding is a list of numbers that represents the meaning of a piece of text. Texts with similar meaning get similar numbers. A chunk about “getting your money back” and a chunk about “refunds” end up close together, even though they share few words.</li><li>Store the embeddings in a vector database. This is a database built to answer one question quickly: which stored chunks are closest in meaning to this new piece of text?</li></ol><h3>Stage two: answering a question</h3><p>This happens each time a user asks something.</p><ol><li>Embed the question. The question is turned into numbers in the same way as the chunks.</li><li>Retrieve the closest chunks. The vector database returns the handful of chunks whose meaning sits nearest to the question.</li><li>Build the prompt. The system writes a prompt that contains the user’s question and the retrieved chunks, along with an instruction such as: answer using only the material below, and say so if the answer is not there.</li><li>Generate the answer. The model reads the prompt and writes a reply grounded in the supplied text.</li><li>Show the sources. Many systems point to the chunks they used, so the user can check the answer.</li></ol><p>That is the whole mechanism. The model itself is unchanged. All of the work happens around it, in what gets found and what gets handed over.</p><h3>A small example</h3><p>Imagine a support assistant for an online shop. A customer writes: “I bought shoes last week and they do not fit. Can I get my money back?”</p><p>The system embeds that question and searches the stored chunks. It returns three pieces: the returns policy, the section on refund timing, and a note about exceptions for sale items. These are placed into the prompt along with the question. The model then replies that the customer has a set number of days to return the shoes, explains how refunds are issued, and mentions that sale items follow different rules. Every detail comes from the shop’s own documents, not from the model’s general habits.</p><p>Change the returns policy next month, update the stored chunks, and the answers change with it. No retraining is needed.</p><h3>Where RAG goes wrong</h3><p>RAG is often described as the cure for made-up answers. It reduces them, but it does not remove them. Most failures come from a few places.</p><ul><li>Retrieval finds the wrong chunks. If the search returns irrelevant material, the model either answers from the wrong text or ignores it. A confident wrong answer built on the wrong source is worse than an honest “I do not know”.</li><li>Chunks are cut badly. If a chunk splits a rule from its exception, the model sees half the picture. Chunk size is a real tradeoff: small pieces are precise but lose context, and large pieces keep context but bring in noise.</li><li>The material is out of date. The system only knows what was last stored. If documents change and the stored chunks do not, the answers quietly become wrong.</li><li>The answer is not in the material. If nothing relevant exists, the model may still produce something. The instruction to admit when the answer is missing needs to be clear, and it needs testing.</li><li>The model drifts from the source. Even with the right text in front of it, a model can paraphrase carelessly or add details that were never there.</li></ul><p>The lesson underneath all of these is that the quality of a RAG system depends mostly on retrieval, not on the model. Better search often improves answers more than a better model does.</p><h3>Security belongs in the retrieval step</h3><p>One point is easy to miss. If your stored material includes documents with different access levels, such as public help pages next to private customer records, then retrieval must respect who is asking. A system that retrieves any chunk for any user can hand one person another person’s data, and the model will explain it politely.</p><p>The rule is simple to state and easy to forget: filter by permission when you retrieve, not after the model has already read the material.</p><h3>RAG, fine-tuning, and long context</h3><p>RAG is not the only option, and it is not always the right one.</p><ul><li>RAG suits knowledge that changes often or that is large, private, or needs to be cited. It is the usual choice for answering questions from documents.</li><li>Fine-tuning adjusts how a model behaves, such as its tone, format, or specialised skill. It is a poor way to teach facts, because the facts go stale and are hard to correct.</li><li>Long context means pasting the whole document into the prompt. For a single short document, this is simpler than building a RAG system and often works well. It becomes expensive and unreliable as the amount of material grows.</li></ul><p>A sensible rule: if the material is small, try putting it all in the prompt first. If it is large, changing, or private, RAG earns its complexity.</p><h3>How to tell whether it works</h3><p>A RAG system should be tested in two parts, because it can fail in two places.</p><ol><li>Test retrieval on its own. Write a set of realistic questions, and for each one, note which chunk should be found. Check whether the search returns it.</li><li>Test the answers. Check that replies are accurate, stay inside the supplied material, and admit it when the answer is missing.</li></ol><p>Skipping the first test is the most common mistake. If retrieval is poor, no amount of work on the prompt will rescue the answers.</p><h3>What to remember</h3><p>RAG is a way of giving a model something to read before it answers. Prepare your material by splitting it and turning it into embeddings. When a question arrives, find the closest chunks, place them in the prompt, and let the model write from them. The model stays the same, and the results depend on how well you find and prepare what it reads.</p><p>If you are building with AI, this is worth understanding properly, because most of what looks like a model problem turns out to be a retrieval problem.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc044989f9ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What I Am Learning About Building Products With AI, From the Inside]]></title>
            <link>https://medium.com/@ojofaith/what-i-am-learning-about-building-products-with-ai-from-the-inside-d7809e393df7?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7809e393df7</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 16:43:14 GMT</pubDate>
            <atom:updated>2026-10-11T17:12:10.113Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IYvUur_hKUWsInhRQlZ1LA.png" /></figure><p>I am a designer, And for a long time, my part of a product ended at the screen. I would make a button look right, decide how it felt to press, and hand it over. What happened after the press was someone else’s problem.</p><p>That stopped being acceptable to me once I started building products with AI. When an AI agent writes code for you, you are the one who has to judge whether that code is good. You cannot judge what you do not understand.</p><p>So I have been studying what sits behind the screen: how a server talks to a database, how information is stored, how user data is protected, how a context file keeps an AI agent consistent, and how the infrastructure holds it all together.</p><p>This article is part record of what I am learning, and part lesson for anyone starting from the same place. I am writing this as someone a few steps into the material, which is sometimes the best position to explain it from.</p><p><strong>The first thing is to follow one tap</strong></p><p>The easiest way to understand a product is to follow a single action from start to finish. Take something simple: a user writes a note and taps Save.</p><ul><li>The app on the user’s device sends a request to the server. The request says who is asking and what they want saved.</li><li>The server checks that the person is who they claim to be, and that they are allowed to do this.</li><li>The server checks the data itself. Is the note empty? Is it absurdly long? Does it contain anything that could cause harm?</li><li>The server tells the database to store the note.</li><li>The database confirms.</li><li>The server sends a response back, and the screen updates.</li></ul><p>From the outside, that is one tap and one small pause. Underneath, it is six steps, and a mistake in any of them can break the product or expose someone&#39;s data. Everything else in this article is a closer look at one of those steps.</p><p><strong>So now how do the server works and the database talk</strong></p><p>The server and the database are two separate things. <em>The server runs the product’s logic:</em> the rules, the checks, the decisions. <em>The database has one job, </em>which is keeping information safe and retrievable. The server asks, and the database answers.</p><p>To connect, the server needs an address and credentials, much like a username and password. These live in something called environment variables, not inside the code itself. This was one of the first things that surprised me. If those credentials sit in the code and the code is ever shared, anyone can walk straight into the database.</p><p>The conversation between the app and the server usually happens through an API, which is an agreed set of requests the server will accept. Think of it as a menu. The app can only order what is on the menu, and the server decides what it will serve. Data travels in a shared format, most often JSON, which is plain text structured so that both sides can read it.</p><p><strong>How do we then keep our information and arranged them</strong></p><p>A database is organised into tables.</p><p>Each table holds one kind of thing: users in one, notes in another. Each row is one item, and each column is one detail about it, such as a name or a date.</p><p>The part that took me longest to appreciate is how the tables relate. A note does not carry the user’s name and email inside it. Instead, each note stores a reference to the user it belongs to, usually an identifier. The user’s details live in one place only.</p><p>As a designer, this felt familiar. It is the same reason a design system has one source for a colour or a component. If the same fact lives in ten places, then one day nine of them will be out of date. Good arrangement of data means each fact has one home, and everything else points to it.</p><p>This matters more than it sounds, because the arrangement is hard to change once real users have filled the database. A poor structure is cheap to fix on day one and expensive on day three hundred.</p><p><strong>We can now talk about how the user data is been protected</strong></p><p>Things the agent should never do</p><p>For a designer, this is the most natural part of the whole subject.</p><p>A context file is a design system written for a reader that is not human. The same discipline applies: decide once, write it down, and make everything else follow.</p><p>There are tradeoffs. A context file that is too long gets skimmed or buried, and a file that has gone out of date is worse than none, because it gives the agent confident, wrong instructions. It has to be kept short and kept current, like any other part of the product.</p><p><strong>Infrastructure</strong></p><p>Infrastructure is the part I understand least, and I would rather say so than bluff.</p><p>What I understand so far is this. Code has to run somewhere, and that somewhere is a server that someone has to provide, pay for, and keep running. The database lives somewhere too, and that is a separate decision.</p><p>When you update the product, there is a process for getting the new version from your computer to the place real users reach it. Most products keep at least two copies of themselves, one for building and testing and one for the public, so that experiments never break what users depend on.</p><p>The questions I am now trying to answer are about what happens under pressure: what the product does when many people arrive at once, how failures are noticed, and how to recover when something breaks. I will write about those once I understand them properly.</p><p><strong>What I take from this so far</strong></p><p>AI makes building faster. It does not remove the need to understand what is being built.</p><p>If anything, it moves the skill. Less of the work is typing code, and more of it is judging code: knowing what should be there, noticing what is missing, and giving the agent enough context to produce something consistent.</p><p>That is why I am learning the layers underneath the screen, even though I came in through the screen. I plan to keep writing as I go, including the parts I get wrong.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7809e393df7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Product Memo ( Abstract )]]></title>
            <link>https://medium.com/@ojofaith/my-product-memo-abstract-e52dbaa6b266?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/e52dbaa6b266</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Fri, 11 Sep 2026 23:36:18 GMT</pubDate>
            <atom:updated>2026-09-11T23:36:18.057Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hwOy8l16PXH4QLEWFeiVcA.png" /></figure><p>Abstract is a simple order management tool for small business owners who currently track orders, payments, and customer information through WhatsApp, notes, spreadsheets, or memory.</p><p>The goal is simple:</p><p>Help a business owner know what they need to prepare, what has been delivered, who has paid, who still owes them, and how the business is doing.</p><h3><strong>The Problem</strong></h3><p>Many small business owners do not have a proper system for managing their daily orders.</p><p>An order might come through WhatsApp, another customer might send an order through Instagram and another might call.</p><p>The business owner may write some things in their notes, remember some things in their head, and keep payment information somewhere else.</p><p>As the number of orders increases, this becomes difficult to manage, orders can be forgotten, payments can be missed and customer information can become scattered.</p><p>The business owner spends time trying to remember what should have been recorded somewhere.</p><p>The problem is not that these businesses need complicated business software.</p><p>The problem is that they need a simple place to keep the important information together.</p><h3><strong>Who This Is For</strong></h3><p>The first version is for small business owners who manage customer orders regularly.</p><p>Examples:</p><p>- Fashion businesses<br>- Food businesses<br>- Bakers<br>- Hair and beauty businesses<br>- Small retailers<br>- Gift businesses<br>- Custom-product businesses<br>- Other businesses that receive and fulfill customer orders</p><p>The first user does not need advanced accounting software, they need something they can understand immediately.</p><h3><strong>The Core User Problem</strong></h3><p>The product should help the user answer five questions:</p><p>1. What do I need to do?<br>2. What orders are currently in progress?<br>3. Who has paid?<br>4. Who still owes me?<br>5. How is my business doing?</p><p>If Abstract cannot answer these questions simply, the product is becoming too complicated.</p><h3><strong>Product Promise</strong></h3><p>Abstract helps small business owners keep track of their orders, customers, and payments without needing complicated business software.</p><p>The product should feel like opening a clean workspace rather than opening accounting software.</p><h3><strong>The Core Workflow</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xBwizQ47WUiLSk2KlRCSPQ.png" /></figure><p>The main workflow is:</p><p>Customer places an order → Business owner adds the order → Order enters “New” → Business owner prepares the order → Preparing → Order is ready → Ready → Order is delivered → Delivered.</p><p>At the same time, the payment status is tracked:</p><p>Unpaid → Paid</p><p>The customer information stays connected to the order.</p><h3><strong>MVP</strong></h3><p>The first version will contain five sections:</p><h4><strong>Dashboard</strong></h4><p>A quick overview of the business.</p><p>- Orders today<br>- Unpaid orders<br>- Overdue orders<br>- Order status overview<br>- Recent orders<br>- Add order</p><h4><strong>Orders</strong></h4><p>The main workspace for managing orders.</p><p>- Create order<br>- Edit order<br>- Delete order<br>- Search<br>- Filter<br>- Payment status<br>- Order status<br>- New<br>- Preparing<br>- Ready<br>- Delivered</p><h4>Customers</h4><p>A simple view of customers connected to orders.</p><p>- Customer list<br>- Search<br>- Customer details<br>- Order history<br>- Total spent<br>- Outstanding balance</p><h4>Reports</h4><p>A simple view of business performance.</p><p>- Total sales<br>- Paid amount<br>- Unpaid amount<br>- Number of orders<br>- Orders by status<br>- Basic sales/order chart<br>- Time filters</p><h4>Settings</h4><p>Basic business configuration.</p><p>- Business information<br>- Owner information<br>- Currency<br>- Basic order settings<br>- Data management</p><h4>What We Are NOT Building Yet</h4><p>The product will deliberately stay small.</p><p>Not in the first version:</p><p>- Inventory management<br>- Full accounting<br>- Payroll<br>- Bank integrations<br>- Expense management<br>- Advanced CRM<br>- Staff management<br>- Complex invoicing<br>- AI bookkeeping<br>- Automated WhatsApp ordering<br>- Advanced analytics</p><p>These may become future opportunities, but they are not necessary to prove the core product.</p><h3>Product Principles</h3><h4>Simple before powerful</h4><p>If a feature requires too much explanation, reconsider it.</p><p>One place for important information : Orders, customers, and payments should not feel disconnected.</p><p>Show what needs attention: Unpaid and overdue orders should be easy to notice.</p><p>Few actions, clear actions: the user should not have to think about how to perform basic tasks.</p><p>No unnecessary complexity: Do not copy features from large business-management platforms simply because they exist.</p><p>The interface should explain itself: A new user should be able to understand the product without training.</p><h3>Design Direction</h3><p>Abstract should feel:</p><p>Simple.<br>Calm.<br>Clear.<br>Practical.</p><p>The existing design system should remain consistent across the product.</p><p>The interface should avoid the feeling of traditional complicated business software.</p><p>The design should give the user enough information to make decisions without overwhelming them.</p><h4>Important Product Assumptions</h4><p>I’m currently assuming:</p><p>- Small business owners regularly lose track of orders or payments.<br>- Existing tools such as WhatsApp and notes are not enough for this workflow.<br>- Users want something simpler than full accounting/business software.<br>- Users will manually enter orders initially.<br>- Connecting customers to orders provides enough value to justify a separate Customers section.<br>- Basic reports are useful even without full accounting functionality.</p><p>These assumptions need to be tested with real users.</p><h3>What Needs Validation</h3><p>Before investing heavily in the product, I need to learn:</p><p>- How do small businesses currently track orders?<br>- What happens when an order is forgotten?<br>- How do they track unpaid customers?<br>- Which information do they check most often?<br>- How many orders do they handle per day/week?<br>- What makes them switch from WhatsApp/notes to another tool?<br>- Would they actually use a dedicated order-management app?<br>- Which businesses have the strongest need for this?</p><p>The goal is not to prove that Abstract is a good idea.</p><p>The goal is to find out whether the problem is painful enough for people to change their current behavior.</p><h3>Success</h3><p>The first success metric is not the number of features.</p><p>I want to know whether users actually use Abstract to manage real orders.</p><p>Early signs of success:</p><p>- Users add real orders.<br>- Users return to check their orders.<br>- Users mark orders as paid.<br>- Users update order statuses.<br>- Users use the customer history.<br>- Users rely on the dashboard to know what needs attention.<br>- Users say that Abstract is easier than their current method.</p><h3><strong>The First Version Should Feel Like This</strong></h3><p>A business owner opens Abstract, within a few seconds they can see:</p><p>12 orders today.<br>3 unpaid.<br>1 overdue.</p><p>They open Orders and immediately see what is new, what is being prepared, what is ready, and what has been delivered.</p><p>They add a new order, the customer is automatically connected to that order.</p><p>Later, they open the customer and see their order history, they open Reports and see how the business is performing and nothing feels complicated.</p><p>That is the experience i am trying to build.</p><h3>Founder Question</h3><p>The question behind Abstract is:</p><p>Can a very simple product help a small business owner move from keeping business information in their head, WhatsApp, and scattered notes to having one clear place to run their daily orders?</p><p>That is what the first version needs to prove, and that is what i build.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e52dbaa6b266" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Happens Behind the Scenes After a User Clicks a Button?]]></title>
            <link>https://medium.com/@ojofaith/what-happens-behind-the-scenes-after-a-user-clicks-a-button-155b2d8092e5?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/155b2d8092e5</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:09:22 GMT</pubDate>
            <atom:updated>2026-09-10T16:09:22.003Z</atom:updated>
            <content:encoded><![CDATA[<h3>What I Am Learning as a Product Designer Becoming a Builder</h3><p>This week, I actually learned so much about what makes products feel fast, secure, and trustworthy and honestly, the more I learn about how products work behind the interface, the more I realize that the things users experience on a screen are connected to so many things happening in the background.</p><p>As a product designer, I used to spend most of my time thinking about what the user sees. The screens, the flows, the buttons, the components, the interactions, the experience but now I am starting to understand what happens after a user clicks that button. Where does the request go? What does the backend do with it? How does the application receive the information? How does it send something back? Why does one product feel fast while another feels slow? What happens when something fails? How does the system protect the user and the business?</p><p>This is what I have been learning as a product designer becoming a builder. I am learning the language that engineers use to build the things I design.</p><p>I started with <strong>APIs</strong>.</p><p><strong>An API</strong>, which means <strong>Application Programming Interface</strong>, is basically a way for different software systems to communicate with each other. As a designer, I can design a screen where a user enters their email and password and clicks “Log in.” But that screen does not actually log the user in. The frontend has to communicate with the backend, and the API is part of the communication between them. The frontend sends information to the backend, the backend processes it, and then sends a response back.</p><p>Then <strong>API endpoints</strong>. An endpoint is basically a specific address where the application can make a particular request. So instead of thinking about an <strong>API</strong> as one big thing, I can think about different endpoints handling different actions. One endpoint might be responsible for getting a user’s profile. Another might create a new account. Another might update an order. Another might delete something. As a designer, understanding this helps me see that the screens I create are connected to specific actions happening in the system.</p><p>Then there is <strong>JSON</strong>.</p><p><strong>JSON</strong> stands for <strong>JavaScript Object Notation</strong>, and it is one of the common ways information is structured and exchanged between applications. It looks a little bit like a collection of information with labels and values. For example, when a user logs into an application, the backend might send information such as the user’s name, email, or user ID in a <strong>JSON</strong> response. I am learning to look at that information and understand what the application is actually receiving, instead of only looking at the final interface.</p><p><strong>Here comes the API keys</strong>. An API key is basically a credential that identifies an application or gives it access to a particular <strong>API</strong>. It is like a way for a service to recognize who is making a request and whether that request should be allowed. This is one of those things that made me think more about security because you cannot just take something like an <strong>API key</strong> and put it everywhere in the frontend where anyone can see it. There are certain things that need to stay protected on the server.</p><p>Then I came across <strong>synchronous and asynchronous operations.</strong></p><p><strong>Synchronous </strong>means something happens and the application waits for that operation to finish before continuing with the next thing.</p><p>while<strong> Asynchronous</strong> means the application can start something that takes time and continue doing other work while waiting for the result. This matters because many things in an application take time. Maybe we are waiting for an API response, uploading a file, processing an image, sending an email, or generating something with AI. If the application waits unnecessarily for everything, the product can feel slow. Understanding this is helping me think about what the user should see while something is happening instead of designing only the final state.</p><p>Then there are <strong>components.</strong></p><p>I already knew components from the design side because I work with reusable UI elements but now I am beginning to understand components from the engineering side too. A component is a reusable piece of an application that can have its own structure, logic, and behavior. A button can be a component. A navigation bar can be a component. A card can be a component. A form can be a component. Instead of building the same thing over and over again, developers can create reusable components and use them in different places.</p><p><strong>Component rendering</strong> is slightly different. The component is the actual reusable piece. <strong>Rendering </strong>is what happens when the application takes that component and displays it on the screen based on the current state and data. So I can have a component for a user profile card, but what appears inside that card can change depending on the user data the application receives. Understanding this difference is helping me connect what I create in a design system to what actually happens in a working application.</p><p>How a <strong>request</strong> actually travels through an application.</p><p>This was one of the things that really helped me connect the dots.</p><p>A user might click a button on the frontend. That action can create an <strong>HTTP request.</strong> The request travels to the appropriate <strong>API endpoint</strong>. The backend receives the request, processes it, possibly talks to a database or another service, and then sends a response back. The frontend receives that response and updates what the user sees.</p><p>So that simple button click I see in Figma can actually represent a whole chain of events happening behind the screen.</p><p>Then I started learning the <strong>HTTP</strong> methods.</p><p><strong>GET</strong> is generally used when we want to retrieve information. If I open my profile and the application needs to get my profile information, it might make a GET request.</p><p><strong>POST</strong> is generally used when we want to create something or send information for the server to process. Creating an account, submitting a form, or creating an order can involve a <strong>POST</strong> request.</p><p><strong>PUT</strong> is generally used to update or replace an existing resource. <strong>PATCH</strong> is also used for updates, but usually when we are changing only part of an existing resource. <strong>DELETE</strong> is used to remove something.</p><p>I know these might sound like very basic engineering concepts, but for me, learning them changes the way I think about product flows. When I design a form now, I am not only thinking about what happens visually after the user clicks submit. I am starting to think about what request is being made, what the backend needs, what response the user should receive, and what happens if the request fails.</p><p>Then there are <strong>HTTP status codes</strong>.</p><p>These are basically signals that tell us what happened with a request.</p><blockquote><strong>200 </strong>usually means the request was successful.</blockquote><blockquote><strong>201</strong> can mean something was successfully created.</blockquote><blockquote><strong>400</strong> means there was something wrong with the request.</blockquote><blockquote><strong>401</strong> usually means authentication is required or the credentials are not valid.</blockquote><blockquote><strong>403</strong> means the request is understood but the user does not have permission.</blockquote><blockquote><strong>404</strong> means the requested resource was not found.</blockquote><blockquote><strong>500</strong> means there was a server-side problem.</blockquote><p>This is becoming useful to me as a designer because these different situations should have different user experiences. If the server returns a 404, the user should not see the same thing they would see after a successful request. If authentication fails, the interface needs to explain what happened. If the server is temporarily unavailable, the experience needs to handle that too.</p><p><strong>Then latency entered,</strong></p><p>Latency is basically the amount of time it takes for a request or response to travel between systems. If a user clicks something and has to wait three seconds before anything happens, that latency affects how the product feels. Sometimes the backend may be doing something complex, but the user does not know that. They only know that the application feels slow.</p><p>This is where things like loading states, optimistic updates, caching, asynchronous operations, and good feedback become important from a product-design perspective. The technical decisions behind the product affect the experience I design.</p><p><strong>SPAs and MPAs.</strong></p><p><strong>SPA </strong>means Single Page Application. The application can load a main page and then dynamically update parts of the interface as the user moves around, rather than loading an entirely new document for every navigation. Many modern web applications work this way.</p><p><strong>MPA</strong> means Multi-Page Application. In this approach, navigation can involve requesting and loading a new page from the server. Both approaches have different technical considerations, and understanding the difference helps me understand why some applications behave differently when users navigate through them.</p><p>Then there is <strong>caching.</strong></p><p><strong>Caching </strong>is basically keeping frequently needed information somewhere that it can be retrieved faster instead of doing the same work repeatedly. For example, if an application constantly needs the same piece of information, it might store a temporary copy so that the next request can be served faster. Good caching can reduce unnecessary work and improve performance. But caching also needs to be handled carefully because old or incorrect information can create problems.</p><p><strong>Middleware and separation of concerns.</strong></p><p><strong>Middleware</strong> is code that sits between parts of a request and response process and can perform certain checks or actions before the request continues. Authentication checks, logging, request validation, and other common operations can be handled through middleware.</p><p><strong>Separation of concerns ( SoC )</strong> is the idea of keeping different responsibilities separated instead of putting everything into one place. The frontend should not be responsible for everything. The backend should not be responsible for everything. Authentication, data access, business logic, presentation, and other responsibilities can be separated. This makes systems easier to understand, maintain, test, and change.</p><p>And this brought me to something I have started thinking about more: building from trust.</p><p>When I say trust, I do not only mean that the interface looks trustworthy. I mean the system itself needs to behave in a way that users can rely on.</p><p>What happens when the network is slow?</p><p>What happens when a request fails?</p><p>What happens when a user clicks the button twice?</p><p>What happens when a service is unavailable?</p><p>What happens when someone sends too many requests?</p><p>What happens when an external service sends information to my application?</p><p>These are product questions, but they also have technical answers.</p><p><strong>Rate limiting</strong> is one of them. Rate limiting controls how many requests a user or system can make within a certain period. This helps protect an application from abuse, excessive traffic, or accidental overload. If an API allows unlimited requests, someone could potentially send thousands or millions of requests and put unnecessary pressure on the system.</p><p><strong>Timeouts</strong> are another part of this. Sometimes a service does not respond. Instead of allowing the application to wait forever, we can set a limit for how long it should wait before giving up.</p><p>Then there is retrying and backoff.</p><p>Sometimes a request fails temporarily. Instead of immediately giving up, the system can try again. But if many requests are all retrying at the exact same time, that can make the problem worse. Backoff means increasing the waiting time between retries, often with some randomness, so that the system does not keep hammering the service while it is already struggling.</p><p>Then I learned about <strong>circuit breakers.</strong></p><p><strong>A circuit breaker</strong> is a pattern that helps prevent one failing service from bringing down everything connected to it. If a service keeps failing, the application can temporarily stop sending requests to it instead of repeatedly making requests that are almost guaranteed to fail. After some time, it can check again to see whether the service has recovered.</p><p>This is another thing that made me realize how much of a product’s reliability happens outside the interface.</p><p>Then there are <strong>webhooks.</strong></p><p><strong>A webhook </strong>allows one system to notify another system when something happens. Instead of my application constantly asking another service, “Did something happen yet?” the other service can send a notification to my application when the event occurs.</p><p>But if my application receives a <strong>webhook, </strong>I also need to make sure that the webhook actually came from the service I trust. This is where webhook verification comes in. The application can verify the request using mechanisms such as signatures so that someone cannot simply send a fake request and pretend that it came from the real service.</p><p>Then there is <strong>idempotency</strong>, which was another concept I found interesting.</p><p>Imagine a user clicks “Pay” and the request is sent. Something goes wrong and the user clicks the button again. If the system treats both requests as completely new payment instructions, the user could potentially be charged twice.</p><p><strong>Idempotency </strong>helps prevent this kind of problem by allowing the system to recognize repeated requests that should have the same effect as the original request. This is especially important for operations such as payments, orders, and other actions where accidentally doing something twice can cause a serious problem.</p><p>The more I learn, the more I realize that designing a product is not only about what happens on the screen.</p><p>There is a whole system underneath that screen.</p><p>A user clicks a button. A request is created. It travels through the application. Middleware may process it. An API endpoint receives it. The backend performs some logic. It may communicate with a database or another service. The system may use caching. There may be authentication and rate limiting. The request may time out. It may be retried. The backend sends a response. The frontend receives it. A component renders the new state. Then the user sees the result.</p><p>All of that can happen because of one click.</p><p>And I think this is one of the biggest things I am learning as a product designer becoming a builder.</p><p>I am learning the language behind the interfaces I design.</p><p><strong>I learnt APIs, endpoints, JSON, API keys, HTTP methods, status codes, latency, caching, middleware, components, rendering, asynchronous operations, system architecture, security, reliability, and all these little things that I previously would have left entirely to the engineering side.</strong></p><p>I am trying to understand enough about how the system works that I can design better products and communicate better with the people building them.</p><p>Because when I understand what happens behind the interface, I start designing differently.</p><p>I start thinking about loading states before someone tells me there will be a delay.</p><p>I start thinking about empty states, errors, permissions, retries, failed requests, authentication, and edge cases.</p><p>I start asking better questions.</p><p>And I think that is what becoming a builder means for me.</p><p>It is moving from only designing what the user sees to understanding what makes that experience actually work.</p><p>From the design file to the dev console.</p><p>That is what I have been learning this week.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=155b2d8092e5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What I Learned This Week About AI Agents and Google Antigravity]]></title>
            <link>https://medium.com/@ojofaith/google-antigravity-how-ai-agents-are-changing-the-way-we-build-software-4704a45a70fc?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/4704a45a70fc</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[google-antigravity-ide]]></category>
            <category><![CDATA[ide]]></category>
            <category><![CDATA[ideas]]></category>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Thu, 27 Aug 2026 07:39:54 GMT</pubDate>
            <atom:updated>2026-08-27T07:58:33.430Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*vp4MQIraaJH8rJT3CZk70g.jpeg" /></figure><p>This week, I learned something that changed the way I think about building software with AI.</p><p>I used to think of AI coding tools mainly as tools that help you write code faster, you describe what you want. The AI generates some code.</p><p>You copy it into your project, test it, find an error, go back to the AI, and repeat the process but there is a much bigger idea behind where AI-assisted development is going.</p><p>It is not just about AI writing code, it is about AI agents being able to actually participate in the process of building a product.</p><p>One of the tools I studied this week that helped me understand this better was Google Antigravity.</p><h3>So, what is Google Antigravity?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*2tmhEPN9LEtt4I4ffsheZw.jpeg" /><figcaption>An agentic environment</figcaption></figure><p>Google Antigravity is an agentic development environment.</p><p>The word “agentic” was one of the things I wanted to understand better.</p><p>An AI agent is different from simply asking an AI chatbot a question, A chatbot can give you an answer.</p><p>An AI agent can be given a goal and then take a series of actions to work toward that goal.</p><p>For software development, this means an agent can potentially inspect a project, understand the relevant files, write or modify code, use the terminal, run the application, interact with the browser, test what it built, identify problems, and make further changes.</p><p>That is a different way of thinking about AI in software development.</p><p>Instead of:</p><p><strong>Human → AI → Code</strong></p><p>we start moving toward:</p><p><strong>Human → Goal → AI Agent → Actions → Working Product a</strong>nd that difference is much bigger than I initially thought.</p><h3>The LLM is not the whole agent</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*jGh-fb0aOl0Yx6nNLQ2Dkg.jpeg" /></figure><p>Another thing I learned is that it is easy to confuse the LLM with the entire AI agent.</p><p>They are not exactly the same thing.</p><p>The LLM is the model doing the language understanding and reasoning but an agent needs more than a model.</p><p>It needs context.</p><p>It needs tools.</p><p>It needs an environment where it can perform actions.</p><p>It needs feedback from those actions.</p><p>So a useful way I now think about an AI agent is:</p><p><strong>LLM + Context + Tools + Environment + Feedback</strong></p><p>The LLM can reason about what needs to happen, but the tools allow the agent to actually do something.</p><p>For example, imagine I tell an agent:</p><blockquote><em>“Fix the broken checkout flow.”</em></blockquote><p>The LLM cannot magically know everything about my application from that sentence.</p><p>The agent needs to gather information.</p><p>It might inspect the project files.</p><p>It might search for the checkout component.</p><p>It might inspect the API being used.</p><p>It might look at errors in the terminal.</p><p>It might open the application in a browser.</p><p>Then it can use the information it collected to determine what is probably wrong.</p><p>This is the part I found particularly interesting.</p><p>The agent is not simply receiving all of the information from me.</p><p>It can investigate the environment itself.</p><h3>How does the agent get the information it needs?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*VptuHZ7IcQerggZeeT_EXw.jpeg" /><figcaption>This was another part I wanted to understand.</figcaption></figure><p>When we say an AI agent “understands the codebase,” that does not mean the LLM has permanently memorized every file in the project.</p><p>Instead, the agent can access the project and gather relevant information.</p><p>Think about it like this, You give the agent a task. the agent first needs to understand the situation.</p><p>So it can inspect files, search through the code, read configuration, look at errors, and interact with the running application.</p><p>The relevant information is then provided to the model as context, the model can reason over that context and decide what to do next.</p><p>This creates a loop:</p><p><strong>Task → Gather context → Reason → Take action → Observe → Reason again</strong></p><p>That loop is one of the biggest things I learned this week.</p><h3>Why the terminal matters</h3><p>Before learning about agentic development environments, I mostly thought of the terminal as something developers manually use to run commands.</p><p>But when an AI agent can interact with the terminal, it becomes part of the agent’s working environment.</p><p>The agent can run commands, start the application, inspect errors, run tests, install dependencies when appropriate, and use the output to decide what to do next.</p><p>For example:</p><p>The agent changes some code <strong>→ </strong>It runs the application <strong>→ </strong>The application produces an error <strong>→ </strong>The agent reads the error <strong>→ </strong>It identifies the relevant code <strong>→ </strong>It makes a change <strong>→ </strong>It runs the application again.</p><p>That means the agent can have a feedback loop with the software it is building.</p><p>It is not simply generating code and hoping the code works, It can actually execute and observe.</p><h3>Then there is the browser</h3><p>This is where things became even more interesting to me.</p><p>Code can be correct and the product can still be wrong.</p><p>A page might technically compile but look terrible on mobile.</p><p>A button might not work.</p><p>A form might not submit.</p><p>A modal might not close.</p><p>A navigation link might lead to the wrong page.</p><p>A developer can discover these things by manually testing the application but an agent with browser access can also interact with the running product, that means the development loop can become:</p><p><strong>Write → Run → Open → Interact → Observe → Fix</strong></p><p>This is important because building a product is not just about producing code.</p><p>You have to verify that the software actually behaves the way you intended.</p><h3>The agent can plan before it builds</h3><p>Another thing I learned is that an agent does not necessarily have to jump straight into writing code.</p><p>For a larger task, it can first break the problem down.</p><p>Imagine I want to build a dashboard for a SaaS product.</p><p>The request might sound simple:</p><blockquote><em>“Build a dashboard for users.”</em></blockquote><p>But that actually contains many smaller decisions.</p><p>What data should appear?</p><p>What components are needed?</p><p>What pages are required?</p><p>How should the data be fetched?</p><p>What happens when there is no data?</p><p>What happens when there is an error?</p><p>What does the mobile version look like?</p><p>How does authentication work?</p><p>Which existing components should be reused?</p><p>An agent can reason through these kinds of questions and create a plan before implementation.</p><p>This is another difference between an AI coding assistant and an agentic development workflow.</p><p>The agent is working toward an outcome rather than simply completing isolated code-generation requests.</p><h3>Artifacts make the work easier to inspect</h3><p>Something else I learned about Antigravity is the idea of artifacts.</p><p>When an AI agent is doing a lot of work, one problem is visibility.</p><p>If the agent changes several files and runs multiple commands, I still need to understand what happened.</p><p>Artifacts provide a way for the agent to communicate its work.</p><p>For example, it can provide a plan, implementation details, screenshots, recordings, or a walkthrough of what it changed.</p><p>This matters because autonomous development creates a trust problem.</p><p>If I am allowing an agent to do more work independently, I need to be able to inspect the result.</p><p>I do not want to simply hear:</p><blockquote><em>“Done.”</em></blockquote><p>I want to know:</p><p>What did you change?</p><p>Why did you change it?</p><p>Did you test it?</p><p>What happened when you tested it?</p><p>Is there anything that still needs attention?</p><p>That is why I think visibility and verification are just as important as autonomy.</p><h3>So, how does this actually help an AI engineer?</h3><p>This is probably the biggest question I had while learning all of this.</p><p>If AI agents can write code, run code, test code, and fix code, what does the AI engineer actually do?</p><p>The answer is not “nothing.”</p><p>The engineer’s role becomes even more important.</p><p>Someone still needs to decide what should be built.</p><p>Someone needs to understand the user’s problem.</p><p>Someone needs to define the requirements.</p><p>Someone needs to make architectural decisions.</p><p>Someone needs to decide what the agent is allowed to do.</p><p>Someone needs to evaluate whether the solution is actually good.</p><p>And someone needs to verify that the final product works.</p><p>This means AI engineering is not simply about knowing how to use an LLM.</p><p>It is about understanding systems and knowing how to work with AI inside those systems.</p><h3>The biggest shift for me</h3><p>The biggest thing I took away from this week’s learning is that I had been thinking about AI at too small a level.</p><p>I was thinking:</p><p><strong>“AI can help me write code.”</strong></p><p>Now I am thinking:</p><p><strong>“AI can potentially participate in the entire software-development loop.”</strong></p><p>That is a much more interesting idea.</p><p>The developer does not necessarily have to manually perform every small action.</p><p>Instead, the developer can define an objective, give the agent the right context and tools, supervise the process, and verify the result.</p><p>The workflow starts looking more like:</p><p><strong>Human defines the problem → Agent understands the task → Agent gathers context → Agent creates a plan → Agent writes and changes code → Agent runs the application → Agent tests the product → Agent observes the result → Agent fixes problems →Human reviews the outcome</strong></p><p>That is what I understand agentic software development to mean.</p><h3>But I do not think this means engineers become unnecessary</h3><p>If anything, I think it makes good engineering judgment more important.</p><p>An agent can execute a poorly defined idea very quickly.</p><p>It can also make a technically reasonable decision that is completely wrong for the product.</p><p>So the human still needs to provide direction.</p><p>The better I understand the product, the architecture, the user problem, and the constraints, the better I can direct the agent.</p><p>This also means that knowing how to verify AI-generated work becomes a real skill.</p><p>You cannot just assume:</p><p><strong>“The AI built it, so it must work.”</strong></p><p>You have to test it.</p><p>You have to inspect it.</p><p>You have to question its decisions.</p><p>You have to understand enough about the system to know when the agent is wrong.</p><h3>What I am taking forward</h3><p>This week changed how I think about building products with AI.</p><p>I am no longer looking at AI only as something that generates code.</p><p>I am starting to see it as another participant in the development process.</p><p>The LLM provides the reasoning capability.</p><p>The agent provides the ability to work toward a goal.</p><p>The tools give the agent ways to interact with the environment.</p><p>The feedback loop allows it to observe what happened and continue.</p><p>And the human provides the direction, judgment, product thinking, and final responsibility.</p><p>That combination is what makes agentic development interesting to me.</p><p>The question is no longer simply:</p><p><strong>“Can AI write code?”</strong></p><p>The more interesting question is:</p><p><strong>“How much of the process of turning an idea into working software can an AI agent actually handle?”</strong></p><p>That is the question I want to keep exploring as I continue learning AI product engineering.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4704a45a70fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[6 Visual Design Principle that are Critical to Modern User Interface.]]></title>
            <link>https://medium.com/@ojofaith/6-visual-design-principle-that-are-critical-to-modern-user-interface-416b7247c1ad?source=rss-579dc340d6bf------2</link>
            <guid isPermaLink="false">https://medium.com/p/416b7247c1ad</guid>
            <dc:creator><![CDATA[Ojo Faith]]></dc:creator>
            <pubDate>Sun, 28 Jul 2024 00:53:26 GMT</pubDate>
            <atom:updated>2024-07-30T08:49:26.471Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>First of all, Before we dive into the world of Visual Design Principle, what is visual design?</strong></h3><blockquote>Visual design involves crafting visual elements like typography, color, layouts, and imagery to communicate a message or evoke an emotion. It focuses on creating aesthetically pleasing and effective design various medium such as websites, advertisements, and printed materials.</blockquote><p>Imagine a scenario without any visual design principle in a user interface, you might encounter a cluttered and chaotic layout with inconsistent color choices, spacing and font styles. Element would be randomly placed without any focus on hierarchy or alignment, making it difficult for users to navigate or understand the effectively. As a result, users would likely experience confusion, frustration, and a lack of trust in the system due to the lack of visual coherence and harmony. For example, in a rush to launch a new mobile application with groundbreaking features, the development team focuses solely on functionality and neglect to incorporate visual design elements. As a result, the app ends up with a cluttered, unappealing interface that confuses users and compromises the overall user experience. With the lack of visual design, important information is not highlighted effectively, navigation is unintuitive, and user find it difficult to engage with the app.</p><p>There are so many visual design principle that are use in designing modern user interface, but we are going to be discussing the six (6) principle that are very critical to modern users interface.</p><p>These are the 6 visual design principle that are critical to modern user interface.</p><h3>1. Visual Hierarchy:</h3><p>Visual hierarchy is the arrangement and organization of visual element in a design in a way that conveys the important of each element to the viewers. this helps guide the viewer’s attention create a clear and structured communication.</p><p>When thinking about visual hierarchy, you want to ask yourself some question like, what do we want to draw attention to? what action do we want our users to take? where does the eye goes to? Asking yourself these questions will allows to create a clear visual hierarchy, because visual hierarchy serve as a way to rank the information you’re consuming. when a user cannot differentiate between the elements, that is said to be that the design as poor hierarchy. below is an example of bad and good visual hierarchy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cvls74wt0GFwZhJNJZ3S1g.png" /><figcaption>Visual hierarchy</figcaption></figure><p>You will see that there is a lot going on, on the left. The two main elements are, the same size, but the bad visual hierarchy has so many colors, which make it hard to know where to look, in the case users become confused, it makes it unclear where the user should look, create a bland design.</p><p>On the right, your eye is automatically drawn to the main box on the left, then goes to element on the right before landing on the orange “call to action button”.</p><h3>2. Contrast:</h3><p>contrast is the visual differences between element on the screen. contrast is used to make certain element stand out and draw attention, improving readability and guiding users through variation in color, size, typography, or spacing.</p><p>For example, in a website interface, using a high contrast between text and background colors can make the text easier to read. creating contrast between the primary action and other surrounding elements can draw user’s attention to that specific button, prompting them to take action. By strategically applying contrast in a UI design, designers can enhance user experience and make the interface more visually appealing and user-friendly. Let take a look at the example below</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1z9ie60yWEmtwZpM6Pij0Q.png" /></figure><p>Using colors with low contrast between the background and the text can make it difficult for the users to read the content (as illustrated on the left). Same apply to images and icons, because image and icons with poor contrast against the background can make them blend in and go unnoticed.</p><h3>3. Alignment:</h3><p>This specifies the appearance and orientation of the edges of a paragraph- -left-aligned text, right-aligned text, centered text, justified-text (aligned evenly from left to right margins). It is about positioning of your elements, including text and imagery, as well as buttons and contents box. To align something in UI design means to position the element with straight line, or in the correct positioning, it ensures that the text as well as the visual element on the screen are positioned linearly and this improve the readability of the website or application, but it also improves the user experience and usability since the navigation become easier. Below is a good example of a poor alignment and a good alignment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sDJEl0Yu2xxROZCzGyXang.png" /><figcaption>ALIGNMENT</figcaption></figure><h3>4. Repetition and Consistency:</h3><p>This involve using the same elements, such as color, fonts, icons, and layouts consistently throughout a product to create a cohesive and recognizable look. Consistency ensures that users have a uniforms and predictable experience when interacting with different parts of an interface. By maintaining repetition and consistency, designers can establish familiarity, build trust, and make it easier for users to navigate and understand the interface. It helps in establishing a visual rhythm that guides users through the product seamlessly. Below is a good example of bad repetition/consistency and good repetition/consistency.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0o-k6PFmhnye5wixv2Xq1A.png" /></figure><h3>5. Proximity:</h3><p>This refers to the visual closeness of element on a screen. it is used to show relationship between different elements and help users understand how they connected or related to each other. Proper use of proximity can improve the overall user experience by, making the interface more intuitive and easier to navigate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J0odAzD3q0NKVMxQ7FxWUA.png" /></figure><h3>6. Balance:</h3><p>It refers to the distribution of elements, such as text, images, and white space, to create visual harmony. It ensures that no single element overpower the others, resulting in a more aesthetically pleasing and easy-to-read layout. Achieving balance involves arranging elements symmetrically or asymmetrically based.</p><p>symmetry refers to elements being evenly balances around a central axis, creating a harmonious and organized layout, while asymmetry involve intentionally placing different visual element in an element in an unbalanced manner to create a dynamic and design that still feels visually appealing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y6iMh_82UDla3lH0kmSWFg.png" /></figure><p>In conclusion, mastering the principles of visual design is very essential for creating impactful and engaging designs that effectively communicate messages to the audience.</p><p>Happy Designing 😌😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=416b7247c1ad" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>