<?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 matt on Medium]]></title>
        <description><![CDATA[Stories by matt on Medium]]></description>
        <link>https://medium.com/@Lmatt?source=rss-11bb3a945d66------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by matt on Medium</title>
            <link>https://medium.com/@Lmatt?source=rss-11bb3a945d66------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:01:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@Lmatt/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[Five Rules for Building with Claude and Coding Agents]]></title>
            <link>https://medium.com/@Lmatt/five-rules-for-building-with-claude-and-coding-agents-fdd30f2c0a8f?source=rss-11bb3a945d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/fdd30f2c0a8f</guid>
            <dc:creator><![CDATA[matt]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 12:17:50 GMT</pubDate>
            <atom:updated>2026-10-08T12:17:50.122Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What I learned from building a memory game with an AI coding agent.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3LWYA4KRdCtrghI2MQ2jRw.png" /></figure><p>My project began with a simple idea: make a memory game where players remember the correct tiles in a grid, with more tiles added at each level. A coding agent can turn a sentence like that into a working first draft, but a useful project takes more than one prompt. It takes clear decisions, steady context, careful checks, and a person willing to own the result.</p><p>The examples in this article come from building <strong>Recall</strong> with a coding agent. The same habits can apply when working with Claude or another AI coding assistant.</p><h3>1. Be Specific</h3><p>The first request described the theme and the broad game loop, but left many details open. What size should the first board be? How many tiles should light up? What happens after a wrong guess? How quickly should later levels become harder?</p><p>We answered those questions over several turns. The board was first set to <strong>5×5</strong>, then the progression was refined to three rounds on <strong>3×3</strong>, four rounds on <strong>4×4</strong>, and five rounds for <strong>5×5 and larger grids</strong>. The first three rounds were given target counts of 3, 4, and 5 tiles. Later, the rule was made consistent: the number of target tiles increases by one each level.</p><p>The final rules are visible in the code:</p><pre>function stageFor(level) {<br>  if (level &lt;= 3) return { size: 3, rounds: 3, start: 1 };<br>  if (level &lt;= 7) return { size: 4, rounds: 4, start: 4 };<br>  const stage = Math.floor((level - 8) / 5);<br>  return { size: Math.min(8, 5 + stage), rounds: 5, start: 8 + stage * 5 };<br>}</pre><pre>function countFor(level) {<br>  return Math.min(18, sizeFor(level) ** 2 - 1, level + 2);<br>}</pre><p>This shows why <strong>“make it harder” is not a complete specification</strong>. A concrete rule such as “add one target tile each round” gives the agent something it can implement and gives me something I can check.</p><p>The same applies to interaction details. A wrong tile costs one life, reveals the missed pattern during a pause, and offers a <strong>Try again</strong> button instead of restarting automatically.</p><p>When describing a feature to a coding agent, I have found it useful to include the <strong>starting state, what changes, and what should happen after success or failure</strong>. The more precise those rules are, the less time I spend correcting the agent’s guesses.</p><blockquote><strong><em>Key lesson:</em></strong><em> Be specific about the behaviour you want, not just the general idea.</em></blockquote><h3>2. Pick the Right Model</h3><p>Not every coding task needs the same amount of reasoning. A small change to a button label is very different from designing a new game loop, tracking how state changes between levels, or finding why a browser interaction has stopped working.</p><p>I used the <strong>balanced model</strong> for this project. That was a sensible fit for work that moved between HTML, CSS and JavaScript and accumulated requirements over many turns.</p><p>The conversation does not compare this model with another model, so I cannot claim it was better than a faster or more capable option. The practical rule is to <strong>choose deliberately and judge the result by how well it handles the task</strong>, rather than simply choosing a model because of its label.</p><blockquote><strong><em>Key lesson:</em></strong><em> Choose a model based on the task you are actually trying to complete.</em></blockquote><h3>3. Manage Context</h3><p>The game changed incrementally. The first version had a grid and a pattern to memorise. Later turns added lives, larger boards, stage lengths, high scores, adjustable pattern time, keyboard support, and a pause after a mistake. Each new request depended on choices made earlier.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/493/1*digbr-b9KMMz5pYWroe-Vg.png" /></figure><p>Good context management means keeping those decisions connected. For example, when a wrong guess began costing a life, the follow-up clarified that the player should see a fresh pattern and manually start it. Later, the pause screen was refined to reveal missed correct tiles. Without the earlier rules, an agent could easily implement one request in a way that breaks another.</p><p>One small example is the retry behaviour. The game waits for the player to press <strong>Try again</strong> instead of launching the next pattern automatically:</p><pre>action.addEventListener(&quot;click&quot;, () =&gt; {<br>  if (phase === &quot;show&quot;) beginPicking(countFor(level));<br>  else start();<br>});</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*dd6B9dntrA4DUTwdj97I-w.png" /></figure><p>That handler depends on context. The same button starts a new pattern when the game is ready, but skips the preview countdown when a pattern is already showing. Understanding the intended states helps me decide whether that shared behaviour is actually correct.</p><p>The project also used a separate folder for a round of improvements before those changes were applied to the original files. This made the work easier to review as a group. Once the enhanced version was accepted, it was copied back and the temporary folder was removed.</p><p>For larger changes, a branch or separate working copy can serve the same purpose: <strong>keep the experiment organised, review the changes, and then deliberately decide what belongs in the main project.</strong></p><blockquote><strong><em>Key lesson:</em></strong><em> Give the agent enough context to understand the project, but keep that context organised and relevant.</em></blockquote><h3>4. Verify Everything</h3><p>Code that looks plausible is not proof that the feature works. This game has timing, visual states, keyboard focus, and progress across multiple rounds. Those behaviours are best checked in the browser.</p><p>For example:</p><ul><li>Does <strong>Skip countdown</strong> hide the pattern immediately?</li><li>Does a wrong answer pause and wait for <strong>Try again</strong>?</li><li>Does the time control stay locked between rounds?</li><li>Does it unlock for a new run?</li><li>Does the modal backdrop advance only when the round is complete?</li></ul><p>The conversation also caught a visual ambiguity. The first attempt to distinguish correct and incorrect tiles still felt difficult to read, so the feedback was revised to use a <strong>white border around missed correct tiles</strong>. This is a useful type of verification: look at the actual result, decide whether it communicates clearly, and adjust it.</p><p>There is also a gap in this project’s process. The changes were not followed by a recorded browser test. User feedback helped refine the design, but it does not replace checking the final version end to end.</p><p>A good handoff should say <strong>what was tested, what was not tested, and any remaining uncertainty</strong>. I should never claim that a feature passed a check that was not actually performed.</p><blockquote><strong><em>Key lesson:</em></strong><em> AI-generated code is a starting point. I still need to test the actual result.</em></blockquote><h3>5. Own Your Code</h3><p>An agent can write the implementation, but the project’s decisions belong to its owner. In this game, I decided that high scores should survive a page refresh but reset when the browser session ends. I also chose three lives, specified when pattern time could change, and clarified that clicking outside a completed-round popup should move the game forward.</p><p>These details are <strong>product decisions</strong>, not just implementation details. The agent can suggest sessionStorage, a modal click handler, or a state variable, but I should still understand the effect.</p><p>In particular, a click outside the popup was made equivalent to pressing <strong>Next round</strong>, because simply hiding the popup would leave the game waiting in an unclear state.</p><p>Before accepting a change, I can ask myself:</p><blockquote><strong><em>Does this match the behaviour I want?</em></strong><em><br></em><strong><em>Can I explain what it does?</em></strong><em><br></em><strong><em>Can I change it later if the project needs to grow?</em></strong></blockquote><p>If the answer is no, I can ask the agent to explain the relevant code or simplify the solution.</p><p>I remain responsible for the software, even when an AI wrote the first draft.</p><blockquote><strong><em>Key lesson:</em></strong><em> AI can help write my code, but I am still responsible for understanding and maintaining it.</em></blockquote><h3>A Better Way to Collaborate</h3><p>The most productive pattern I found is a simple loop:</p><p><strong>Describe → Build → Inspect → Refine → Verify</strong></p><p>I describe one concrete outcome, let the agent make the change, inspect the result, and refine the requirement when reality exposes a gap.</p><p>In this project, the game became more useful through small corrections: <strong>bigger tiles, clearer lives, staged grid growth, controlled retries, and more legible feedback.</strong></p><p>Claude and coding agents can speed up this development loop. They work best when I give them clear rules, enough context, and honest feedback, while still taking responsibility for the final result.</p><p>The biggest thing I have learned is that using a coding agent is not about handing over the whole project and hoping it works. It is about <strong>working with the AI as a tool while I remain the developer making the decisions, checking the results, and owning the code.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fdd30f2c0a8f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Introduction to Prompt Engineering]]></title>
            <link>https://medium.com/@Lmatt/my-introduction-to-prompt-engineering-c8a06af50860?source=rss-11bb3a945d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8a06af50860</guid>
            <dc:creator><![CDATA[matt]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 10:07:24 GMT</pubDate>
            <atom:updated>2026-10-08T10:07:24.070Z</atom:updated>
            <content:encoded><![CDATA[<p>As I have progressed through my Level 3 Software Development bootcamp, I have started to understand that using AI is not just about asking it a question and expecting the perfect answer. The way I write my prompt can have a big effect on the response I get. This is where prompt engineering comes in. Prompt engineering is the process of writing prompts in a clear and useful way so that AI has a better understanding of what I am asking it to do.</p><p>At the beginning, I would often ask very short questions such as “fix my website” or “how do I do this?” and expect the AI to understand exactly what I meant. I have realised that these prompts do not give the AI much information to work with. By giving it more useful information about what I am trying to achieve, the problems I am having and how I want the answer presented, I can get a response that is much more relevant to me.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jHdida-JvaDrwjC82MiE_A.png" /></figure><h3>Role</h3><p>One part of a prompt that can be useful is <strong>Role</strong>. This is where I tell the AI who I want it to act as. For example, I could say, “You are a patient web development tutor.” This can help set the type of response I am looking for. As a beginner, asking the AI to act as a patient tutor would encourage an explanation that is easier for me to understand rather than an overly advanced answer.</p><h3>Task</h3><p>The <strong>Task</strong> is what I actually want the AI to do. I have learned that it is better to use a clear action rather than making the request too vague. Words such as “build”, “fix” or “explain” make it clearer what I want the AI to do. For example, instead of saying “my navigation is not working”, I could ask the AI to “explain how I can fix the navigation layout on my website”.</p><h3>Context</h3><p><strong>Context</strong> is the information that helps the AI understand my situation. This could include my level of experience, what project I am working on, what programming languages I am using and what I have already tried. For example, when working on my restaurant website, I could explain that I am a beginner using HTML, CSS and JavaScript and that I am using Flexbox for the navigation. This gives the AI more information about my project and makes its response more relevant.</p><h3>Constraints</h3><p><strong>Constraints</strong> are the rules or limits I want the AI to follow. This could be something such as not using frameworks, keeping the solution beginner-friendly or making sure the website works on mobile devices. I think this is useful because otherwise the AI might suggest a solution that works but does not fit the requirements of my project. Adding constraints helps keep the response focused on what I actually need.</p><h3>Format</h3><p><strong>Format</strong> is about how I want the answer to be presented. For example, I could ask the AI to explain the problem first, then show the corrected CSS and finally explain what has changed. This is useful for me because I am still learning, so I do not always want just a piece of code with no explanation. Asking for a specific format can make the answer easier to follow and understand.</p><h3>Example</h3><p>Another useful part is <strong>Example</strong>. This means giving the AI an example of the type of response or style I am looking for. I have found that showing the AI what I mean can sometimes be easier than trying to describe it. For example, if I wanted a simple explanation suitable for a beginner, I could provide an example of the writing style I want it to use.</p><h3>I Do Not Need to Use All Six Parts</h3><p>I have also learned that I do not need to use all six parts in every prompt. The six parts are more like a guide to help me decide what information the AI needs. For a simple question, I might only need a clear task and a small amount of context. For example, if I wanted to know what a piece of CSS does, I would not necessarily need to explain my role, give an example or specify a particular format.</p><p>However, if I was asking AI to help me solve a larger problem with a website, adding more context and constraints would make the response more useful. This has helped me understand that prompt engineering is not about making every prompt as long and detailed as possible. It is about <strong>giving the AI the right information for the task</strong>.</p><h3>An Example Prompt</h3><p>Here is an example of a prompt I could use when working on my website:</p><blockquote><strong><em>You are a patient web development tutor.</em></strong><em><br></em><strong><em>Explain</em></strong><em> how I can fix the navigation layout on my website.<br>I am a beginner on a Level 3 Software Development bootcamp. My website is for a restaurant and I am using HTML, CSS and JavaScript. I am using Flexbox for the navigation.<br></em><strong><em>Do not use frameworks. Explain the solution at beginner level.</em></strong><em><br></em><strong><em>Explain the problem first, then show the corrected CSS and explain what you changed.</em></strong></blockquote><p>This example shows how I can give the AI enough information to understand what I am trying to achieve without making the prompt unnecessarily complicated. Each part has a purpose, but I would only include the parts that are useful for the particular question I am asking.</p><h3>What I Have Learned</h3><p>Learning about prompt engineering has changed the way I use AI during my course. I now understand that if I give AI a vague question, I might get a vague or overly complicated answer. By giving it clear instructions and enough context, I have more control over the type of response I receive.</p><p>I also think prompt engineering is particularly useful for me as a beginner because I can use AI as a learning tool rather than simply asking it to do the work for me. I can ask it to explain code, help me understand an error or show me an example and then learn from the response. I still need to understand and check what the AI gives me, but writing better prompts makes it much easier to get an answer that actually helps me learn.</p><p>Overall, I have learned that good prompting is mainly about <strong>being clear about what I need</strong>. I do not have to use all six parts every time, and I do not need to write extremely long prompts. Instead, I can choose the parts that are relevant to the task and give the AI enough information to understand what I am trying to achieve. This is something I can continue using throughout the rest of my software development course and when working on future projects.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8a06af50860" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Experience Building the FoodSpot Restaurant Website]]></title>
            <link>https://medium.com/@Lmatt/my-experience-building-the-foodspot-restaurant-website-f827478c00ec?source=rss-11bb3a945d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/f827478c00ec</guid>
            <dc:creator><![CDATA[matt]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 09:35:48 GMT</pubDate>
            <atom:updated>2026-10-08T09:35:48.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wYci9OoEQR5zlAevqymjbg.png" /></figure><h3>Introduction</h3><p>For this project, I created a restaurant website called <strong>FoodSpot</strong>. The website includes information about the restaurant, its menu, its team, customer reviews and information about where the restaurant is located.</p><p>At the start of the project, I found it difficult to understand how all the different HTML elements would fit together on the page. I knew what I wanted the website to look like, but I needed to work out how to structure the HTML and then use CSS to create the layout.</p><p>One thing that helped me was thinking about the website in terms of <strong>parents and children</strong>. Once I started looking at the HTML this way, Flexbox and Grid became easier to understand because I could see how a parent element could control the position of its child elements.</p><h3>Breaking My Website Into Parents and Children</h3><p>When I first started working on the website, I realised that I needed to break it into smaller sections instead of thinking about the whole page at once.</p><p>My main content contains different sections, including the introduction, menu, team, reviews and the section where customers can find the restaurant. Each section has a parent element containing different child elements.</p><p>For example, my menu has a parent called .menu-grid, which contains individual .dish articles:</p><pre>&lt;div class=&quot;menu-grid&quot;&gt;<br>  &lt;article class=&quot;dish&quot;&gt;<br>    &lt;img src=&quot;...&quot; alt=&quot;Freshly made special sandwich&quot;&gt;<br>    &lt;div class=&quot;dish-info&quot;&gt;<br>      &lt;div&gt;<br>        &lt;h3&gt;Special sandwiches&lt;/h3&gt;<br>        &lt;p&gt;Fresh fillings, toasted sourdough&lt;/p&gt;<br>      &lt;/div&gt;<br>      &lt;span&gt;£12&lt;/span&gt;<br>    &lt;/div&gt;<br>  &lt;/article&gt;<br>&lt;/div&gt;</pre><p>When I look at this now, I can see the different levels more clearly. .menu-grid is the parent, while .dish is one of its children. The .dish then becomes a parent to its own children, such as the image and .dish-info.</p><p>Thinking about the HTML in this way helped me because I could decide where I wanted to apply my CSS. Instead of trying to position every element individually, I could use the parent to control how its children were arranged.</p><h3>Using Flexbox for My Navigation</h3><p>One of the first places where I used Flexbox was my navigation bar.</p><p>I wanted the FoodSpot logo on one side and the navigation links on the other. My HTML structure made these elements children of the .nav parent:</p><pre>&lt;nav class=&quot;nav wrap&quot; aria-label=&quot;Main navigation&quot;&gt;<br>  &lt;a class=&quot;brand&quot; href=&quot;#home&quot;&gt;<br>    food&lt;span&gt;spot&lt;/span&gt;&lt;i&gt;.&lt;/i&gt;<br>  &lt;/a&gt;</pre><pre>  &lt;div class=&quot;nav-links&quot; id=&quot;nav-links&quot;&gt;<br>    &lt;a href=&quot;#story&quot;&gt;Our story&lt;/a&gt;<br>    &lt;a href=&quot;#menu&quot;&gt;The menu&lt;/a&gt;<br>    &lt;a href=&quot;#team&quot;&gt;Our people&lt;/a&gt;<br>  &lt;/div&gt;<br>&lt;/nav&gt;</pre><p>I then used Flexbox on the parent:</p><pre>.nav {<br>  height: 100%;<br>  display: flex;<br>  align-items: center;<br>  justify-content: space-between;<br>}</pre><p>Before working on this project, I understood that display: flex was used for layouts, but I didn&#39;t fully understand how the different properties affected the children.</p><p>Using justify-content: space-between helped me understand this better. It places the children with space between them, which allowed me to have the logo on one side and the navigation links on the other.</p><p>I also used Flexbox on .nav-links:</p><pre>.nav-links {<br>  display: flex;<br>  align-items: center;<br>  gap: 33px;<br>}</pre><p>The gap property was useful because it gave my navigation links space between them without me having to add margins to every individual link.</p><p>This was one of the areas where I started to feel more comfortable with Flexbox because I could change a few properties and immediately see how the layout changed.</p><h3>Using Flexbox Inside My Menu Items</h3><p>I also used Flexbox for smaller parts of the website.</p><p>Each menu item has the food name and description on the left and the price on the right. I used .dish-info as the parent:</p><pre>.dish-info {<br>  display: flex;<br>  justify-content: space-between;<br>  gap: 12px;<br>  padding-top: 16px;<br>}</pre><p>The children of .dish-info are the &lt;div&gt; containing the food information and the &lt;span&gt; containing the price.</p><p>I used justify-content: space-between to push these two parts apart.</p><p>This helped me understand that Flexbox doesn’t have to be used for an entire section of a website. I can use it inside a smaller component as well.</p><p>I think this is one of the main things I have learned from this project. I used to think about CSS as styling individual elements, but now I am starting to think more about the <strong>relationship between elements</strong>.</p><h3>Using Grid for My Menu</h3><p>Although I used Flexbox in several areas, I found that Grid was better for the main menu layout.</p><p>I wanted my menu to display three dishes across the page on a larger screen. I used:</p><pre>.menu-grid {<br>  display: grid;<br>  grid-template-columns: repeat(3, 1fr);<br>  gap: 22px;<br>}</pre><p>The .menu-grid is the parent and each .dish is a child.</p><p>The repeat(3, 1fr) creates three equal columns. This made it much easier to arrange the six menu items.</p><p>I found Grid easier for this particular situation because I was thinking about the layout as rows and columns. Flexbox made more sense to me when I was arranging items in one direction, such as the navigation or the price and description.</p><p>This helped me start to understand when I might choose Grid instead of Flexbox.</p><h3>Learning From the Team Section</h3><p>I used Grid again for the team section.</p><p>The team cards are children of .team-grid:</p><pre>.team-grid {<br>  display: grid;<br>  grid-template-columns: repeat(5, minmax(0, 1fr));<br>  gap: 16px;<br>}</pre><p>I wanted the team members to appear across the page rather than being displayed as one long list.</p><p>Looking back at my code, I can see that I am using the same basic idea in several places: <strong>a parent controls the overall layout and the children contain the actual content</strong>.</p><p>This has made the HTML structure easier for me to understand. When something doesn’t appear in the correct place, I can look at its parent and work out whether the layout is being controlled there.</p><h3>Making the Website Responsive</h3><p>One of the areas I found important was making the website work on smaller screens.</p><p>A layout that looks good on a desktop screen isn’t necessarily going to work well on a phone. Because of this, I used media queries to change the layout.</p><p>For example, my menu starts with three columns:</p><pre>.menu-grid {<br>  display: grid;<br>  grid-template-columns: repeat(3, 1fr);<br>  gap: 22px;<br>}</pre><p>But when the screen is 760px or smaller, I change it to one column:</p><pre>@media(max-width:760px) {<br>  .menu-grid {<br>    grid-template-columns: 1fr;<br>    gap: 28px;<br>  }<br>}</pre><p>This was useful because I didn’t need to create a completely different HTML structure for mobile. I could keep the same parent and child elements and change how the parent displays its children.</p><p>I also changed the navigation on smaller screens. The navigation links are initially hidden and JavaScript adds the is-open class when the menu button is clicked.</p><pre>links.classList.toggle(&#39;is-open&#39;, !isOpen);</pre><p>The CSS then changes how the links are displayed:</p><pre>.nav-links.is-open {<br>  display: flex;<br>  flex-direction: column;<br>}</pre><p>This was a good example of different parts of my project working together. The HTML provides the structure, CSS controls the layout and JavaScript changes the navigation when the user interacts with it.</p><h3>What I Found Difficult</h3><p>One of the things I found difficult was understanding why an element was not always moving when I changed its CSS.</p><p>I sometimes expected to be able to change the position of an individual element, but the parent container was actually controlling the layout.</p><p>This made me realise that when I am having a problem with the position of an element, I shouldn’t only look at that element. I should also look at its parent and see whether it is using Flexbox or Grid.</p><p>For example, if a child is inside a Flexbox container, properties such as justify-content and align-items on the parent can affect where the child appears.</p><p>This is something I understand much better now than I did at the beginning of the project.</p><h3>What I Would Improve</h3><p>If I built the website again, I think I would spend more time planning the structure before writing the CSS.</p><p>I found that once I had a clear parent and child structure, the CSS became easier to manage. If I started changing the layout without understanding the HTML structure first, I could make things more complicated for myself.</p><p>I would also test the website at different screen sizes earlier in the development process. I added responsive CSS, but I think checking the mobile layout more regularly would have helped me identify problems earlier.</p><p>Another thing I would like to improve is my understanding of Flexbox and Grid. I can now use them in my projects, but I still sometimes need to experiment with properties to understand exactly what they are doing.</p><h3>What I Have Learned</h3><p>The biggest thing I have taken from this project is that building a website is not just about making individual elements look good. The structure underneath them is just as important.</p><p>Thinking about elements as <strong>parents and children</strong> has helped me understand how HTML and CSS work together.</p><p>I have also become more confident using Flexbox. I now understand that I can use the parent to control the position of its children using properties such as:</p><pre>display: flex;<br>justify-content: space-between;<br>align-items: center;<br>gap: 33px;</pre><p>I have also learned that Grid can be useful when I need to create rows and columns, such as my menu and team sections.</p><p>Most importantly, I feel that I am starting to understand <em>why</em> I am using certain CSS properties instead of just copying code and changing values until the website looks right.</p><p>As I am now at Week 10 of my 16-week Level 3 Software Development bootcamp, I can see that I have made progress from where I started. I still have a lot to learn, but building this website has helped me understand how HTML structure, CSS layout and JavaScript can work together to create a functional website.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f827478c00ec" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning About Flexbox and Webpage Layout]]></title>
            <link>https://medium.com/@Lmatt/learning-about-flexbox-and-webpage-layout-a2a57547bf8b?source=rss-11bb3a945d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2a57547bf8b</guid>
            <category><![CDATA[flexbox]]></category>
            <dc:creator><![CDATA[matt]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 11:17:47 GMT</pubDate>
            <atom:updated>2026-09-10T11:17:47.901Z</atom:updated>
            <content:encoded><![CDATA[<p>This week in my Level 3 Software Development course, I continued building my understanding of HTML and CSS. One of the CSS concepts I found particularly useful was <strong>Flexbox</strong>.</p><p>Before learning about Flexbox, positioning different elements on a webpage could sometimes feel confusing. I understood that HTML was responsible for creating the structure and CSS controlled how the webpage looked, but I was still learning how to control where elements were positioned and how they interacted with each other. Learning about Flexbox started to make this much clearer.</p><h3>What is Flexbox?</h3><p>Flexbox is a CSS layout system that allows elements within a container to be arranged and aligned more easily.</p><p>To start using Flexbox, I can use the display: flex property:</p><pre>.container {<br>    display: flex;<br>}</pre><p>This turns the element with the container class into a <strong>flex container</strong>. The elements inside it then become <strong>flex items</strong>, allowing me to control how they are positioned and spaced.</p><p>This gave me a different way of thinking about webpage layout.</p><p>Instead of trying to position every element individually, I can create a container and then control how the elements inside that container should be arranged.</p><h3>Controlling the direction of elements</h3><p>One of the first Flexbox properties I learned about was flex-direction.</p><p>By default, Flexbox arranges items in a row:</p><pre>.container {<br>    display: flex;<br>    flex-direction: row;<br>}</pre><p>This means the elements will generally appear next to each other.</p><p>I can also change the direction to a column:</p><pre>.container {<br>    display: flex;<br>    flex-direction: column;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bFkGxeP-9qdAW3xV.png" /></figure><p>This places the elements underneath each other.</p><p>This was useful because it showed me that I could change the layout without needing to change the HTML structure itself.</p><h3>Aligning elements with Flexbox</h3><p>Another part of Flexbox that I found useful was being able to control how elements are aligned.</p><p>Two properties I started working with were:</p><pre>justify-content<br>align-items</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ne6tKWS9B0pTP5h0.png" /></figure><p>justify-content controls how the flex items are positioned along the main axis, while align-items controls their alignment along the cross axis.</p><p>For example:</p><pre>.container {<br>    display: flex;<br>    justify-content: center;<br>    align-items: center;<br>}</pre><p>This can be used to position items in the centre of their container.</p><p>I found this particularly useful because positioning elements manually can become complicated. Flexbox provides properties that allow me to describe how I want the elements to be arranged rather than having to work out exact positions myself.</p><h3>Understanding spacing</h3><p>Flexbox also helped me understand how spacing between elements can be controlled.</p><p>For example:</p><pre>.container {<br>    display: flex;<br>    gap: 20px;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/501/0*DS6LGnm2hDCv4Mvl" /></figure><p>The gap property creates space between the flex items.</p><p>This is something I found useful when creating layouts because it makes it easier to keep consistent spacing between elements.</p><p>Instead of adding margins to individual elements, I can use the container to control the space between its children.</p><h3>HTML and CSS working together</h3><p>Learning Flexbox also reinforced something I learned previously about the relationship between HTML and CSS.</p><p>HTML creates the elements and their structure, while CSS controls how those elements are presented.</p><p>For example, I could have three &lt;div&gt; elements in my HTML:</p><pre>&lt;div class=&quot;container&quot;&gt;<br>    &lt;div&gt;Item 1&lt;/div&gt;<br>    &lt;div&gt;Item 2&lt;/div&gt;<br>    &lt;div&gt;Item 3&lt;/div&gt;<br>&lt;/div&gt;</pre><p>Then I can use CSS to control their layout:</p><pre>.container {<br>    display: flex;<br>    gap: 20px;<br>    justify-content: center;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7CipcULYkpqnBFONh4jgjQ.png" /></figure><p>The HTML hasn’t changed, but the way the elements are displayed has.</p><p>This helped me see how HTML and CSS complement each other. <strong>HTML provides the structure, while CSS controls how that structure is arranged and presented to the user.</strong></p><h3>Flexbox and responsive layouts</h3><p>Another thing that has made Flexbox interesting to me is how it can help create layouts that adapt to different screen sizes.</p><p>For example, flex-wrap allows flex items to move onto another line when there isn&#39;t enough space:</p><pre>.container {<br>    display: flex;<br>    flex-wrap: wrap;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*RP7WBp5TCURVeQ8mHoyApA.png" /></figure><p>This becomes particularly useful when creating websites that need to work across different devices.</p><p>A layout that looks good on a large desktop screen may need to behave differently on a tablet or mobile phone. Flexbox provides tools that can help elements adjust rather than relying on fixed positions.</p><p>This has made me realise that web development isn’t just about making a webpage look good on my own screen. I also need to think about how other users might view and interact with it.</p><h3>What I’m taking away from this week</h3><p>The biggest thing I have taken away from learning Flexbox is that webpage layout doesn’t have to be about manually positioning every element.</p><p>Flexbox gives me a way to think about the <strong>relationship between elements</strong>.</p><p>I can create a container, add my elements inside it and then use properties such as:</p><ul><li>display: flex</li><li>flex-direction</li><li>justify-content</li><li>align-items</li><li>gap</li><li>flex-wrap</li></ul><p>to control how those elements behave.</p><p>I’m beginning to understand that good CSS isn’t just about making something look good. It’s also about creating a layout that is structured, predictable and easier to maintain.</p><h3>Looking ahead</h3><p>I’m still developing my understanding of CSS, but learning Flexbox has made webpage layouts feel much less intimidating.</p><p>It’s also shown me how individual CSS properties can work together to solve a larger problem.</p><p>I’m looking forward to continuing to experiment with Flexbox and learning more about responsive layouts, particularly how websites can adapt to different screen sizes.</p><p>As I continue through my Level 3 Software Development course, I’ll keep documenting what I learn, the problems I encounter and the solutions I discover along the way.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2a57547bf8b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning the Building Blocks of the Web — HTML, CSS and the Browser]]></title>
            <link>https://medium.com/@Lmatt/learning-the-building-blocks-of-the-web-html-css-and-the-browser-d3be15bdafa8?source=rss-11bb3a945d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3be15bdafa8</guid>
            <category><![CDATA[css]]></category>
            <category><![CDATA[html]]></category>
            <dc:creator><![CDATA[matt]]></dc:creator>
            <pubDate>Thu, 03 Sep 2026 10:47:26 GMT</pubDate>
            <atom:updated>2026-09-03T10:47:26.515Z</atom:updated>
            <content:encoded><![CDATA[<p>This week in my Level 3 Software Development course, I started getting to grips with two of the fundamental technologies behind websites: HTML and CSS.</p><p>One of the most interesting parts of the week was understanding that when we create a webpage, we are not just writing code — we are also learning how that code interacts with the browser and how the browser interprets it to create what we see on screen.</p><h3>HTML: Giving a webpage structure</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/0*F6VJ2O0cDBNhKzkg" /></figure><p>I learned that HTML (HyperText Markup Language) is responsible for the structure and content of a webpage.</p><p>Headings, paragraphs, images, links and other sections are represented using HTML elements. The browser reads this HTML and uses it to build the structure of the webpage that we interact with.</p><p>This helped me understand that there is a connection between what I write in my code editor and what eventually appears in the browser.</p><h3>CSS: Controlling how the webpage looks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eXigxLHkScBFWRae.png" /></figure><p>I then explored CSS (Cascading Style Sheets), which is used to control how those HTML elements appear in the browser.</p><p>This includes things such as:</p><ul><li>Colours and backgrounds</li><li>Fonts and text</li><li>Sizes</li><li>Borders</li><li>Spacing</li><li>Positioning</li></ul><p>What I found particularly useful was being able to make a change in my CSS and then see the effect immediately in the browser.</p><p>That interaction made the learning process much more practical. Instead of just reading about a concept, I could experiment with it, observe the result and adjust my code.</p><h3>Understanding the CSS Box Model</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0nif5O2TyMOBibT8" /></figure><p>One concept that particularly stood out to me was the CSS Box Model.</p><p>The Box Model helped me understand how the browser calculates the space occupied by different elements on a webpage.</p><p>Each element can essentially be thought of as a box made up of:</p><p>Content → Padding → Border → Margin</p><p>Understanding the difference between these areas helped explain why an element might not appear exactly where I expected it to.</p><p>For example, padding creates space inside an element, while margin creates space outside it.</p><p>Seeing these changes directly in the browser helped make the concept much easier to understand.</p><h3>What I’m taking away from this week</h3><p>The biggest lesson for me wasn’t simply learning HTML and CSS syntax. It was beginning to understand the relationship between code, the browser and the user experience.</p><p>When something doesn’t look right on a webpage, I can now start thinking about questions such as:</p><ul><li>Is my HTML structure correct?</li><li>Is the CSS being applied to the correct element?</li><li>Is padding creating unexpected space?</li><li>Is margin affecting the position?</li><li>How is the browser interpreting my code?</li><li>What happens when I change the code and refresh the page?</li></ul><p>This way of thinking is something I want to continue developing throughout the course.</p><h3>Looking ahead</h3><p>This is still the beginning of my software development journey, but I’m enjoying seeing how individual concepts connect together.</p><p>I’m particularly interested in continuing to learn how developers use code to create webpages that people can interact with through their browsers.</p><p>I’ll continue documenting my progress, the challenges I encounter and the things I build as I work towards developing my skills in software development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3be15bdafa8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Development Life Cycle: Agile and Waterfall Methodologies]]></title>
            <link>https://medium.com/@Lmatt/software-development-life-cycle-agile-and-waterfall-methodologies-178578cebc52?source=rss-11bb3a945d66------2</link>
            <guid isPermaLink="false">https://medium.com/p/178578cebc52</guid>
            <category><![CDATA[sdlc]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[waterfall-methodologies]]></category>
            <dc:creator><![CDATA[matt]]></dc:creator>
            <pubDate>Thu, 27 Aug 2026 12:55:47 GMT</pubDate>
            <atom:updated>2026-08-27T12:55:47.954Z</atom:updated>
            <content:encoded><![CDATA[<p>Software Development Life Cycle: Agile and Waterfall Methodologies</p><p>Introduction</p><p>The Software Development Life Cycle (SDLC) is a process used by software development teams to plan, create, test, release and maintain software. It provides a structured way of developing software and helps teams make sure that the final product meets the needs of its users and the organisation.</p><p>There are different methodologies that can be used when following the SDLC. Two of the best-known approaches are Waterfall and Agile. Although both approaches aim to produce high-quality software, they organise the development process in different ways. Waterfall follows a more traditional, step-by-step process, while Agile focuses on flexibility, collaboration, regular feedback and developing software in smaller stages.</p><p>Figure 1 — Software Development Life Cycle</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/0*XEbPxmOC9a-r9DJk.png" /></figure><p>Figure 1 shows the main stages of the Software Development Life Cycle, including planning, requirements, design, development, testing, deployment and maintenance.</p><p>What is the Software Development Life Cycle?</p><p>The SDLC consists of several stages that a software project normally goes through. The exact stages can vary between organisations, but they commonly include planning, requirements, design, development, testing, deployment and maintenance</p><p>Planning</p><p>During planning, the development team identifies the purpose of the project. They consider factors such as the expected costs, timescale, resources and potential risks.</p><p>Requirements</p><p>The requirements stage involves identifying what the software needs to do. Developers and other members of the team may gather information from customers, users and other stakeholders.</p><p>Design</p><p>During the design stage, the team decides how the software will be structured and how it will work. This can include designing the user interface, database and technical architecture.</p><p>Development</p><p>During development, programmers write the code and build the software based on the requirements and design.</p><p>Testing</p><p>The software is tested to identify errors and make sure that it works as expected. Testing can include checking individual components as well as the complete system.</p><p>Deployment</p><p>Once the software has been developed and tested, it can be released to its users. The deployment process may vary depending on the type of software.</p><p>Maintenance</p><p>After deployment, developers continue to maintain the software. This can involve fixing bugs, improving performance, updating security and adding new features.</p><p>Following an SDLC can help organisations manage software projects more effectively because it provides a process for planning, developing and checking the quality of software.</p><p>The Waterfall Methodology</p><p>Waterfall is a traditional software development methodology that follows a linear and sequential process. This means that the project moves through a series of stages, with each stage normally being completed before the next one begins.</p><p>Figure 2 — Waterfall Development Model</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oOtENXy82lXG4Ejl.jpg" /></figure><p>Figure 2 shows how the Waterfall methodology moves through each stage in a set order. The project normally starts with requirements and planning, followed by design, development, testing and deployment.</p><p>The Waterfall methodology normally involves detailed planning at the beginning of the project. Requirements are identified before development starts, and there is usually less opportunity to make major changes once the project is underway.</p><p>Advantages of Waterfall</p><p>One advantage of Waterfall is that the process is straightforward and easy to understand. The development team has a clear sequence of stages to follow, which can make the project easier to plan and manage.</p><p>Another advantage is that requirements and documentation are usually established early. This can be useful when the requirements are well understood and are unlikely to change.</p><p>Waterfall can also be useful for projects where detailed documentation, predefined requirements and clear milestones are important.</p><p>Disadvantages of Waterfall</p><p>A major disadvantage of Waterfall is that it is less flexible than Agile. If a customer changes their requirements after development has started, making those changes can be difficult and expensive.</p><p>Another disadvantage is that users may not see a working version of the software until late in the project. This means that problems with the original requirements or design may not be discovered until much later.</p><p>For this reason, Waterfall can be less suitable for projects where requirements are uncertain or likely to change.</p><p>The Agile Methodology</p><p>Agile is an approach to software development that focuses on flexibility, collaboration, feedback and incremental delivery. Instead of attempting to complete the whole project in one sequence, Agile teams divide the work into smaller pieces.</p><p>Agile projects commonly use short development cycles called sprints or iterations. During a sprint, the team selects work to complete, develops and tests it, and then reviews the results. Feedback can then be used to decide what should be worked on during the next sprint.</p><p>Figure 3 — Agile Development Process</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/0*_FMZbV7O4OIrFZNh.png" /></figure><p>Figure 3 shows how Agile development works in repeated cycles. Instead of completing the whole project in one sequence, developers repeatedly plan, develop, test and review smaller parts of the software.</p><p>Agile also places importance on communication with customers and stakeholders. Regular feedback allows the team to learn more about what users need and make changes during development.</p><p>Advantages of Agile</p><p>One of the biggest advantages of Agile is flexibility. Requirements can change during the project, allowing the development team to respond to new information and customer feedback.</p><p>Another advantage is that working software can be delivered regularly. Instead of waiting until the end of the entire project, users can receive useful features during development.</p><p>Agile also encourages regular testing and feedback. Problems can therefore be discovered earlier, potentially making them easier and less expensive to fix.</p><p>Agile can also improve communication because developers, customers and other stakeholders are encouraged to work together throughout the project.</p><p>Disadvantages of Agile</p><p>Agile also has some disadvantages. Because requirements can change regularly, it can be more difficult to predict the exact cost and completion date of a project.</p><p>Agile also requires good communication and commitment from team members and stakeholders. If customers are not available to provide feedback, the benefits of the approach can be reduced.</p><p>Another possible disadvantage is that maintaining consistency across many sprints and releases can be challenging if the project is not managed effectively.</p><p>Agile vs Waterfall</p><p>Although both methodologies can be used to manage software development, their approaches are quite different.</p><p>Waterfall:</p><p>- Linear and sequential<br>- Requirements are usually established early<br>- Development follows predefined stages<br>- Testing generally occurs after development stages<br>- Working software is normally delivered later<br>- Less flexible when requirements change<br>- More emphasis on upfront planning and documentation</p><p>Agile:</p><p>- Iterative and incremental<br>- Requirements can change throughout development<br>- Development takes place in repeated cycles<br>- Testing takes place regularly<br>- Working software can be delivered incrementally<br>- Designed to respond to change<br>- More emphasis on collaboration and feedback</p><p>Figure 4 — Agile vs Waterfall Comparison</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FRxdSRgeA9Pw4c3j" /></figure><p>Waterfall may be appropriate when requirements are clearly understood and unlikely to change. Agile is generally more suitable when requirements are uncertain, users need to provide regular feedback or the project is expected to change during development</p><p>Choosing the Right Methodology</p><p>There is no single methodology that is suitable for every software project. The choice should depend on the requirements, risks, users, timescale and type of project.</p><p>For example, a project with clearly defined requirements and strict documentation requirements may benefit from Waterfall. In contrast, a new application where developers need regular feedback from users may benefit from Agile.</p><p>Some organisations may also use a hybrid approach, combining elements of Waterfall and Agile. This can allow an organisation to have some of the structure of Waterfall while still being able to respond to changes in requirements.</p><p>Conclusion</p><p>The Software Development Life Cycle provides a structured process for developing and maintaining software. Common stages include planning, requirements, design, development, testing, deployment and maintenance.</p><p>Waterfall and Agile provide two different ways of managing software development. Waterfall follows a structured, sequential approach and can work well when requirements are clearly understood and unlikely to change. However, it can be difficult to respond to changing requirements.</p><p>Agile is more flexible and focuses on smaller development cycles, regular testing, collaboration and customer feedback. This makes it useful for projects where requirements may change, although it can be more difficult to predict the final scope, cost and timescale.</p><p>Overall, the best methodology depends on the individual project. Understanding the differences between Agile and Waterfall allows a software development team to choose an approach that is appropriate for its users, requirements and working environment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=178578cebc52" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>