Posts

Showing posts from 2026

Building My Automated Social Media Publisher — Part 3: Building the Machine

Image
In the first two parts of this series, I explained why I wanted to automate the promotion of my blog posts and why we eventually decided to use Buffer as the intermediary between our application and the social networks. That decision solved one major problem, but it left another one: What exactly should our application do? The temptation when starting a software project is to keep adding features. Once you realise that something is possible, it is very easy to decide that the application should do that as well. We deliberately went in the opposite direction. Start With the Actual Job The application had one basic purpose: take articles from my blogs and turn them into scheduled social-media promotions. Everything else was secondary. That gave us a relatively short list of things the appli...

Building My Automated Social Media Publisher — Part 2: Finding the Middleman

Image
In Part 1, I explained how the idea began with a fairly simple problem: I wanted to automate the repetitive job of promoting my blog posts on social media. Our first instinct was to connect the application directly to the social networks. It was a logical idea, but the more we considered it, the less attractive it became. Every social network meant another API, another authentication system, another set of permissions and another integration to maintain. So we changed the question. What if my application only had to talk to one service? Looking for an Intermediary What we were looking for was effectively a middleman. My application would prepare the promotion and tell the intermediary where and when it should be published. The intermediary would then deal with the individual social networks. ...

Building My Automated Social Media Publisher — Part 1: The Problem

Image
Publishing a blog post is only part of the job. Once an article is written and published, there is another task waiting: getting people to actually see it. With several blogs producing articles on different subjects, that means repeatedly creating social-media posts, deciding where they should go, deciding when they should appear, and remembering to do it. At first, this doesn't seem particularly difficult. One article, one social-media post — job done. But multiply that across several blogs and several social networks, and the simple task becomes a recurring administrative chore. The Problem I Wanted to Solve That was the problem I wanted to solve. I didn't want to build a giant social-media management system. I wasn't interested in replacing the commercial platforms that already exist, and I certainly didn't need hundre...

How Far Can You Push Blogger?

Image
Part One asked why you might choose Blogspot as the platform for your website. The answer was surprisingly simple: free managed hosting, a built-in publishing system, Google's infrastructure and the ability to create your own design. But that leaves a much more interesting question. How far can you actually push it? If Blogger is going to be the foundation of a website rather than simply a place to publish a conventional blog, then the real test is what you can build on top of it. Can you create a website that looks and behaves like a conventional, professionally designed site? Can you create your own components? Can you build a design system? Can you integrate other services? And eventually, where does Blogger stop being enough? You control much more of the front end than you might expect The first thing to understand is the distinction between the front end and the back end . The front end is what the visitor sees and interacts with. The back end i...

Why Choose Blogspot as the Platform for Your Website?

Image
Can you build a proper website using Blogger? Yes. But that leads to a more interesting question: why would you choose Blogger as the platform for a website? When most people hear Blogger , or its familiar Blogspot address, they probably think of a blog. They imagine a page containing a stream of articles, perhaps with a sidebar and a collection of Blogger gadgets. But Blogger doesn't actually require your website to look like that. With a sufficiently customised template, you can build your own HTML structure, your own CSS, your own navigation, your own components and your own visual identity. At that point, the question becomes less about whether Blogger can be used for a website and more about whether there is any particular reason not to use it. The biggest attraction is remarkably simple: Blogger gives you free hosting. Free hosting is a pretty big deal If you build a conventional website, one of the first things you normally have to consider is h...

User Functionality Part 4: From Accounts to Capabilities

Image
Once the framework had a common Account page, I had solved one problem. Users now had somewhere to go to manage their account. But that immediately created another question. What exactly should a user be able to manage? At first this sounds like an application-navigation problem. If someone uses the Publications application, give them a link to Publications. If they use the Marketplace, give them a link to Marketplace. But I wanted something more structured than a collection of application links. I wanted the account area to describe the things that a user could actually do. That led to the idea of capabilities. A capability is not simply an application. It describes something that the user can manage or access. For example, one of the framework's planned capabilities is: Manage My Publications Another is: Manage My Marketplace Business Those names are deliberately written from the user's perspective. They aren't saying "Go to the Publicati...

User Functionality Part 3: Building a Common Account Area

Image
Once authentication had become a framework responsibility, the next question was fairly obvious. If the framework knows who I am, where do I go to manage my account? Until this point, the individual applications had been the things users interacted with. The framework existed largely behind the scenes, providing the infrastructure that made those applications work. User accounts changed that relationship. The framework now had something that users needed to interact with directly. That led to the idea of a common Account page. Rather than having each application create its own account page, the framework could provide one place where a user could see their account and the functionality available to them across the website. This might sound like a relatively small interface decision, but it reinforced an important architectural principle. The account belongs to the user, not to the application. If I use the Publications application and then move to the Marketplace, I s...

User Functionality Part 2: Making Authentication a Framework Responsibility

Image
Once I had decided that the website should have user accounts, I had to answer a fairly important question. Where should authentication live? The obvious answer, if I was thinking about the individual applications, would have been to put it in each application. After all, an application needs to know whether someone is logged in. But that immediately brought me back to the problem that had started the whole framework project in the first place. Duplication. If Publications had its own authentication system, and Marketplace had another, and another application had another, I would once again have several versions of essentially the same functionality. That wasn't what I wanted. If a user account belonged to the website rather than to an individual application, then authentication needed to belong to the platform as well. That was an important distinction. The applications shouldn't each have to work out how to authenticate a user. They should simply be able to ...

User Functionality Part 1: Then I Said: “Let’s Have User Accounts”

Image
When I started building the Auspice Darer Framework, I wasn't trying to create a framework. I was trying to solve problems as they appeared. The original problem was duplication. I had a number of PHP applications, and each one had developed its own header, footer, navigation and supporting code. Making a change to one application was easy enough. Making the same change consistently across all of them was where the time went. So the first stage was fairly straightforward. I began bringing the applications together under a common structure, sharing things that didn't need to be independently maintained. That was already making life easier. Then, at some point, I had another idea. Why not have user accounts? It sounds like a fairly ordinary feature. Most websites have them. But in the context of what I was building, it changed the nature of the project. Until then, the applications could largely be thought of as separate programs that happened to live on the sam...

Know When to Stop Patching

Image
One of the biggest lessons I learned while working with AI wasn't about prompting. It wasn't about context windows. It wasn't about choosing the right model. It was about recognising when neither the AI nor I were solving the right problem. Software development has a habit of encouraging incremental fixes. A bug appears. You fix it. Another edge case appears. You patch that too. Eventually the code works—but it becomes increasingly difficult to understand why. AI can unintentionally reinforce this pattern. If you ask it to solve today's problem, it will usually do exactly that. If another problem appears tomorrow, it will solve that one too. Before long you've accumulated a series of perfectly reasonable fixes that, taken together, have become an increasingly awkward design. I saw this happen more than once while building the Auspice Darer Framework. We would spend time refining an approach, improving it a little with each iteration, only to realise that the underly...

You're Still the Software Architect

Image
One of the biggest misconceptions about AI-assisted software development is that the AI is somehow "in charge" of the project. It isn't. No matter how capable AI becomes, the responsibility for the overall architecture still belongs to the human developer. I learned this repeatedly while building the Auspice Darer Framework. Most of the time, the AI produced excellent ideas, spotted bugs I had overlooked and suggested cleaner implementations than I might have written myself. But occasionally it would head in the wrong direction. Sometimes it would forget an important design decision we'd made earlier. Sometimes it would suggest a solution that ignored one of the framework's architectural principles. Sometimes it would continue reasoning from an assumption that was no longer true. When that happened, I discovered something important. The AI doesn't know it's gone wrong. It simply continues reasoning from the information it believes to be correct. That's...

Stop Uploading One File at a Time

Image
One of the first habits I had to change when working with AI on software projects was how I shared my code. Initially, I'd upload one file, ask a question and wait for the AI to request the next file. Then another. Then another. If you've ever done this with a large application, you'll know how quickly it becomes a game of "Can I see the next file?" The problem isn't that the AI is asking the wrong questions. The problem is that it can only reason about the information it has available. If the bug appears in a controller but is actually caused by a service, configuration file or bootstrap process, the AI has no way of knowing that until it sees those files as well. Before long, you've spent more time uploading files than discussing the solution. Eventually I started taking a different approach. Whenever I was working on something that involved architecture, debugging or major refactoring, I'd simply upload a ZIP archive of the entire project. That chan...

Why I Use Multiple AI Chats Instead of One Huge Conversation

Image
When people first start using AI for software development, they often treat it like a search engine. They open a single conversation and keep asking every question in the same place. I started that way too. For small projects, it works perfectly well. Large software projects are different. As my work on the Auspice Darer Framework grew, I realised that one conversation was trying to cover too many different topics at once. One moment I was discussing dependency injection, the next I was redesigning CSS, then debugging routing, before switching to documentation or database design. The conversation became cluttered, and the AI had to continually switch context. Eventually I tried something different. Instead of one conversation, I created a project and gave different chats different responsibilities. One chat focused entirely on framework architecture. Another concentrated on CSS and presentation. Others were dedicated to individual applications, documentation, testing or specific migrat...

Architecture Exists to Make Change Cheap

Image
When people hear the word architecture , they often imagine something complicated. Layers. Patterns. Dependency injection. Service containers. Routing. They're all useful tools, but they're not the reason architecture exists. For me, architecture serves a much simpler purpose. It makes change inexpensive. That lesson wasn't something I learned from a book. It was something I discovered by maintaining an increasing number of applications. Every time I found myself making the same change in multiple places, I asked the same question. "Why isn't there just one place to change this?" Over time those questions shaped the Auspice Darer Framework. There became one shared configuration. One common layout. One routing system. One authentication service. One way of rendering pages. One location for reusable components. Instead of every application deciding how to solve these problems, they all relied on the same shared platform. The result wasn't simply less code. I...

From Shared Code to Shared Architecture

Image
By this point I knew what the problem was. Every new application meant another copy of the same infrastructure. Every improvement meant updating multiple projects. The duplication wasn't making development difficult—it was making maintenance expensive. My first instinct wasn't to build a framework. It was simply to stop copying code. The obvious place to start was with the parts that almost never differed between applications. The website header. The footer. The navigation. Instead of maintaining separate copies, I began sharing them between applications. Suddenly a change to the site's appearance only needed to be made once. That small change had a surprisingly large effect. The more code I shared, the more I realised that the same principle applied elsewhere. Configuration files didn't need to exist in every project. Common helper functions didn't need to be duplicated. Authentication didn't need to be rewritten. Database access could be standardised. Even the...

The Hidden Cost of Change

Image
When I first started writing my own PHP applications, every project was self-contained. That seemed like a sensible approach. Each application lived in its own directory, had its own configuration files, its own navigation, its own page layout and its own collection of helper functions. There were no dependencies between projects, and that meant I could develop each one independently. For a while, that worked perfectly. The problem wasn't building new applications. The problem was changing existing ones. Imagine deciding that your website header needs redesigning. Perhaps you want to add a search box, change the navigation or update your branding. With a single application, that's a straightforward task. With ten independent applications, it becomes ten separate tasks. Every header had to be updated. Every footer had to be updated. Every navigation menu had to be updated. Every configuration change had to be copied into every project. Every bug fix had to be repeated. None of t...