Using AI for your co-op needs
Small businesses, including many broadband cooperatives, often face a difficult trade-off: invest in the products and services customers rely on, or invest in the software tools needed to operate more efficiently. Many of the workflows we deal with every day have already been automated by larger organizations. The problem isn't that solutions don't exist; it's that they're usually packaged into expensive software whose subscription cost can exceed the value of the efficiency it creates for smaller organizations. Until now.
In this article, I'll discuss how AI has made custom software development more accessible to organizations with limited budgets. Instead of paying a vendor that has dominated their vertical with a "one size fits most" approach, businesses now have the capabilities to build the software they want to fit their workflow exactly. With AI, a single developer or even a subject matter expert can transform business knowledge into working software. By developing your own software, you move from renting a solution forever to investing in an asset. However, inexpensive code is not the same as reliable software.
My goal is to help you build a secure, consistent, maintainable platform that can grow with your organization, not just a bunch of individual features.
Start with a Foundation
Before writing any code, consider starting with a proven project template instead of building everything from scratch. Mature starter projects provide many of the common features every application needs, allowing you to focus on solving your organization's business problems rather than rebuilding infrastructure.
If you're using Django, I recommend Cookiecutter Django for applications serving a single organization and SaaS Pegasus for multi-tenant applications.
Recommendation: Don't start from scratch unless your requirements demand it. Use a mature starter project to accelerate development and reduce maintenance.
Source control
Source control is the safety net that allows you to experiment with AI without risking your application by storing and tracking changes. These features allow you to have an audit trail, version history, and most importantly a method to roll back changes. AI can make sweeping changes across your codebase, and asking it to "put everything back" rarely restores the application exactly as it was.
Recommendation: Use Git from day one. Whether you host your own GitLab instance or use GitHub, every meaningful change should be committed before asking an AI to make the next one.
Tip: Create a standard naming convention. I like to use "Feature:" for things that are brand new functionality, not necessarily related to existing pages. I use "Enhancement:" for adding features to existing functionality. Finally I use "Bug:" for fixes.
Tip: Commit before every major AI prompt. If you're about to ask the AI to refactor authentication, redesign a page, or implement a new feature, create a commit first. Think of commits as restore points that let you experiment without fear.
Continuous Integration
When you push code up to your source control, continuous integration allows you to run pre-defined tests against your code to make sure it fits within your organizations standards for production. This automated quality gate is going to be critical to ensuring that you are not breaking existing functionality while also enforcing secure, well documented code. Whereas the AI may tell you everything is good, continuous integrations is your second opinion.
Recommendation: Include tests for these major sections of your application: code formatting, code quality, unit testing, code security, and documentation. Here is my stack: Black (formatting), Ruff (quality), PyTest (unit testing), Bandit (security), PipAudit (security) and Heredoc (documentation).
Tip: Don't write a single feature without having the AI build unit tests. That way, as you develop more features, the system will automatically detect if past features break based on new code (regression testing).
Tip: Don't push code into production outside of your CI engine. Setup your pipeline so that you can have the option to push to production from your CI Runners.
Tip: Don't allow code to enter production until all tests are passing.
Development server
One of the biggest advantages of AI is how quickly it allows you to experiment. A development server gives you the freedom to try new ideas, throw them away, and iterate rapidly without risking customer data or interrupting your organization's daily operations.
Recommendation: At a minimum, maintain separate development and production environments. As your application grows, introduce a staging or testing environment that mirrors production as closely as possible.
Tip: Treat your development environment as disposable. If an AI experiment leaves it in a bad state, you should be able to rebuild it quickly rather than spending hours trying to repair it.
Warning: Never point your development environment at your production database. AI-generated code can modify or delete data much faster than a human developer. If you have to point at a production database, utilize a wrapper script which enforces limitations that the AI can't get around.
API first
When you begin building features, make sure your AI is building the features with APIs to start with. You don't need to know every future use case. You only need to avoid preventing those future use cases. Its highly likely that you may encounter a situation where other software around the organization wants to plug into your software and this will speed that process up significantly. Get it right from the beginning.
Recommendation: Every feature that contains business logic should expose that logic through an API rather than embedding it exclusively in the user interface.
Tip: Build the API first, then have the AI build the user interface against that API. If you later build a mobile app, another website, or an AI agent, they'll already have a stable interface to use.
Automate Documentation
AI can dramatically reduce the effort required to keep documentation current. I like to talk a lot about bus factors which are a measurement of business continuity as it relates to a given position if that person were to get hit by a bus. By having your AI automatically document your application as it goes on, you can easily hand the project off, train employees, and maintain healthy business continuity practices.
Recommendation: Have your AI keep a set of documenting files up to date with each feature. At a minimum: architecture, design, feature guidelines, developer hand off, and run books.
Tip: Anytime you utilize an external API, keep a local version of that API in your repo.
Tip: Anytime you spend discovering database schemas or poorly documents systems, have the AI save your discoveries.
Tip: Treat documentation as part of the definition of done. A feature isn't complete until both the code and its documentation have been updated.
Consistent User Experience
Before you start building a bunch of features and pages for your new application, you are going to want to experiment with the AI to design a set of reusable components you like. Once you determine how components should look, you can determine how they should behave. At a minimum, you need to be thinking through the following components: header, footer, siderbar (recommended), navigation, cards, tables, forms, modals, notifications, banners, heros, searches, filters, states (error, empty, loading), and confirmation dialogs.
Recommendation: Choose a mature UI framework or design system and stick with it. Consistency is far more important than whether you choose Bootstrap, Tailwind CSS, or another framework. Before building your first feature, have the AI create a reusable component library and instruct it to use those components for every subsequent page.
AAA
Authentication, Authorization, and Accounting are very early features you need to get in place before you implement anything user facing. Single sign-on and multi-factor authentication are no longer optional. When it comes to accounting, build a global audit and logging framework and send your logs off to a central database that can be analyzed and monitored.
Recommendation: Do not build your own authentication, utilize an existing active directory services but layer on SSO/MFA along with a remote syslog server
Tip: Build logging as shared infrastructure, not as an afterthought for individual features. You will find lots of reasons to store a record of an event throughout your application.
Role-based access control
One of the easiest mistakes to make is assuming today's users will always have today's responsibilities. RBAC will allow you to control the four fundamental actions in any software: Create, Read, Update, and Delete. It will save your sanity later when someone inevitably asks, "Can customer service see this but not edit it?"
Recommendation: Have your AI implement at least CRUD permissions for each user facing feature.
Tip: If you think users may eventually customize dashboards or build their own screens, design permissions around reusable interface components (cards, widgets, or sections), not just entire pages.
Warning: Avoid both extremes. Permissions that are too broad become security risks, while permissions that are too granular become difficult to understand, assign, and maintain.
Conclusion
The practices outlined in this article aren't meant to slow you down, they're what allow you to move quickly with confidence. Build the foundation first, and every feature you add afterward will be more secure, more maintainable, and far easier to evolve as your organization grows.
In the next article, we'll build on that foundation by exploring the some features that we've built into Falcon that may interest you.