AI in the Loop: Reflections on Delivering the HULA Workshops at Founders & Coders

Sunday, 4 May 2025

A month ago, I had the chance to facilitate a workshop series at Founders & Coders with Jack Casstles-Jones, my co-facilitator, introducing developers to a new approach for building software with AI as a partner. The room was filled with developers of varying experience levels, all curious about how AI might change their day-to-day work. In preparation for these sessions, we spent time researching and experimenting with different ways of bringing AI into the software process, with the idea being that it would enhance your learning rather than atrophying your skills. What we ended up with was quite an elaborate framework which we decided to call the HULA (Human-in-the-Loop) framework, a term we "borrowed" as it is already being used in AI and ML with a slightly different meaning. Over several sessions, we continued to develop this framework from constant feedback given to us by the attendees who tested it themselves. This month, we are starting these up again to explore agentic workflows and more, so it is a good moment for me to look back and reflect on the first iteration of these.

Read more about the HULA Framework: if you are interested in using the framework on your projects, you can find our documentation by clicking on the link.

AI as an unstoppable force

We began each workshop by opening the floor to participants' thoughts on AI, from opportunities to legal, ethical and environmental concerns. Among the various perspectives shared, one comparison stood out to me: the parallel with the industrial revolution. Historically, this comparison is often drawn in a positive light, emphasising how initial fears of machines taking jobs ultimately led to more skilled work and the modern work culture we know today. Of course, this transformation wasn't without significant growing pains - economists recognise Engels' Pause, that difficult 50-year period where technological advancement outpaced wage growth, creating widespread hardship before benefits eventually diffused through society. More concerning still, one participant insightfully noted that the industrial revolution came with enormous environmental costs that we're still paying for. Similarly, training large AI models carries a significant carbon footprint, raising valid environmental concerns even as the technology creates new possibilities.

What history has shown us, though, is that technological revolutions tend to be unstoppable forces. The Luddites who opposed industrial machinery were ultimately swept aside by the wave of progress. If we accept that AI development follows a similar trajectory, then regardless of our ethical or environmental concerns, we have little choice but to adapt. The sensible approach seems to be embracing AI while maintaining both healthy scepticism and a clear moral compass to guide our engagement with it.

Learning to be a senior engineer

After the initial discussion, we continued to clarify what the workshop was not about. These sessions weren't aimed at building the next ChatGPT or a deep dive into tools like LangChain and LangGraph. Our focus was using AI as a collaborative tool in regular software development - treating AI like a team member whilst keeping a human in control of decisions.

As AI becomes increasingly proficient in coding, more tickets that previously would have been assigned to juniors can now go directly to AI assistants. This shift means that senior engineering skills are becoming more valuable. The industry may eventually evolve towards a model where human engineers focus on high-level decision-making while AI handles implementation details (with a strong guiding hand). In essence, we could be witnessing a compression of the traditional career ladder.

The concept we introduced was of the "human-in-the-loop", which means using AI as a highly proficient junior developer and pair programming partner while retaining control over the architectural and design decisions. This allows us as developers to focus our attention on higher-level logic such as architecture, system design and how components and interfaces should interact. It is not about taking shortcuts to senior roles, but rather about intelligent upskilling in areas where AI isn't yet masterful. It's about maximising the value of your time by focusing on developing skills that complement rather than compete with AI. By understanding this dynamic, developers can position themselves strategically in an evolving industry landscape. This framing set the stage for the practical methodology that followed.

Tools and model taxonomy

We established a taxonomy of AI models to help developers choose the right tool for each task:

Category	Model Examples	Notable Capabilities
Reasoning Models	o1, DeepSeek-R1, Claude 3.7	Mathematical reasoning, logical inference
Thinking Models	o3, Llama 2, Grok3	General cognitive tasks, creativity
Conversational Models	ChatGPT 4o, Claude 3.5, Grok2	Dialogue, user intent understanding, lower cost

This taxonomy was mapped to different phases of development in the HULA framework. We had participants explore popular large language models and consider where in the software development lifecycle each might be most useful.

To get everyone comfortable with AI-assisted coding, we had them install a CLI tool called Aider or Anthropic's newly released Claude Code to build a simple Node.js calculator app. This practical exercise demonstrated how an AI pair-programmer can accelerate trivial coding tasks through natural language commands, and got everyone set up quickly for the main task of the day.

Maintaining critical thinking: actions to follow when working with AI

One key part that we wanted to stress was a general set of actions that can help you work with AI effectively and intelligently, to avoid the blind copy-pasting of AI outputs and ensure your project is on the right track. These can apply to any situation where you might use AI in your work, and these actions should be repeated at each stage of the HULA process described next. They are:

Iterate: Share your ideas with an LLM and build the required output through iterative refinement. You can prompt AI to ask targeted questions to help develop detailed requirements.
Question: Review AI's output summary, identify gaps, and refine the output as well as your understanding of it (if required) through follow-up questions.
Review/Create: Review the generated output, understand it. When necessary, combine AI insights with your ideas to create a final spec in plain text format. If AI has presented 10 solutions, you come up with the 11th. File the output in your repo.
Explain: Present the output to stakeholders/team members/clients, emphasising its clear foundation and alignment with architectural principles set out by you (if applicable). For this, we encouraged participants to communicate with those on their table at the end of each phase and explain to one another.

The HULA Framework: six phases of AI-assisted development

The core of our workshop that participants' were asked to follow when developing was the six-phase HULA structure, with each phase aligning to a typical stage of software development:

Conception: Using a conversational AI to brainstorm and define requirements. Through iterative Q&A, the AI helps flesh out a detailed functional specification. Think of this as rubber ducking with a powerful sounding board that can look up information much faster than you would be able to otherwise. Output: SPEC.md.
Design and Architecture: Using a thinking model to aid in designing the system architecture. The AI suggests possible designs, discusses trade-offs, and considers principles that you feed it such as KISS and DOTADIW. Explore component breakdowns and design patterns, question choices for scalability and maintainability, then integrate the best ideas. Output: Architecture Decision Record (ADR.md).
Planning: With the spec and ADR, now we employ a thinking model to outline a detailed implementation plan. The AI helps draft a step-by-step blueprint for the build, breaking the project into small, manageable chunks. Iterate and question how incremental and atomic each step should be. Optionally, if time allows, we also recommended using a conversational AI before this to discuss and draw up a project standards spec. The latter can be used to guide the implementation model to write code the way you would write it and avoid AI spaghetti code. Output: PLAN.md and optionally STANDARDS.md.
Implementation: Switching to a reasoning model for actual coding. Taking prompts from the plan and feeding them to the AI, then testing and reviewing the generated code, and improving on it as you progress. This process is repeated incrementally for each prompt in the plan.
Testing: Using the same AI that helped write the code to generate unit tests, suggest edge-case scenarios, and ensure good test coverage. In a TDD workflow, this phase can be combined with the previous.
Deployment: Employing AI for deployment planning and automation. The AI outlines deployment strategies and generates configuration scripts, which are then verified and tweaked by developers.

Throughout all phases, we emphasised the importance of model selection - using the right AI tool for each job.

Effective Prompting with HULA

For each HULA phase, we demonstrated a specific prompting structure:

Anatomy of the Prompts

Role: Give the LLM an expert role for an agentic-like workflow. LLMs respond better when given a specific perspective.
Task: The actual prompt - what we want to get out of the interaction.
Criteria: Special criteria the model should follow (e.g., use PEP 8 standards for Python code).
Output: We provided templates for outputs at each phase:
- Functional spec template (Phase 1)
- Architectural decision record template (Phase 2)
- Project standards spec template (Phase 3)
- Implementation plan template (Phase 3)

These templates are based on IEEE 830 standard for SRS, but participants could also use their own formats or allow the LLM to determine the best structure.

HULA in action: how far did we get?

To put theory into practice, we suggested participants build a Travel Planning App using the HULA framework, though many actually used the opportunity to work on personal projects they'd been wanting to start for some time, and we encouraged this. This flexibility allowed them to apply the framework to problems they were genuinely invested in solving.

Participants primarily worked individually with AI rather than in teams, coming together between phases to compare and discuss their outputs. This approach revealed how different conversations with AI led to varied functional specifications even when starting from similar prompts. For the conception phase, developers engaged with models through browser interfaces like ChatGPT using custom prompts that positioned the AI as an "expert Product Requirements Engineer." When comparing notes afterward, it was interesting to see how their individual interactions had steered the AI toward different aspects of the project.

Moving through the subsequent phases (Design & Architecture and Planning) participants continued this pattern of individual work followed by group discussion. Some fed their specs to more powerful models like OpenAI's o3, setting its persona to "expert Software Architect" and debating the AI's suggestions based on their own experience. We encouraged those with less expertise to continuously question the AI about decisions it wants you to make in order to understand and be able to make an informed judgement. The Planning phase yielded task lists that became prompt scripts for implementation, though few reached this final stage within the workshop timeframe.

During implementation, we encouraged participants to move to the CLI, using tools like Aider or Claude Code. Some participants were already familiar with AI-assisted code editors such as Cursor or Windsurf and opted to continue in those environments, while others did brave the command line. From these interfaces, they were able to follow the prompt plan generated in the previous phase and reached diferent levels of success with it. During this phase, we stressed the importance of following the 4 actions, particularly the review part - no line of code should be commited until you understand what it does.

Given the intensive nature of the process, most participants were unable to complete their projects during the workshop. Some showed impressive progress with partially functioning applications, while others indicated they would continue using the HULA workflow at home to complete their project. This outcome wasn't surprising - the framework is thorough and demands significant mental engagement at each stage.

In our closing reflection, one participant's comment underlined the mental exercise that is this process: they felt mentally exhausted after working through the framework. Far from seeing this as negative, they recognised it as evidence they were genuinely stretching their capabilities rather than taking shortcuts. This sentiment echoed our core message, which is that HULA isn't about offloading thinking to AI, but rather about structuring your collaboration with AI to push your understanding further. Several participants expressed how they could see immediately applying this framework to their projects, appreciating its balance of structure and flexibility.

Looking ahead: multi-agent workflows

The workshops were an experiment in teaching not just how to write code, but how to collaborate with AI to write code - all while reinforcing software engineering fundamentals. By focusing on high-level concepts and problem-solving while letting AI handle some of the rote tasks, developers potentially learn faster and build more without losing depth of understanding.

The core principle of being the human-in-the-loop remains crucial. As we reminded participants, "This is the worst AI will ever be, and the worst you will ever be at using AI". The technology will only get more powerful, and we as developers will get better at harnessing it.

The HULA framework gives developers a language and structure to work with AI systematically rather than ad-hoc. It's not the only approach, but it's a solid starting point that balances AI power with human control.

Later this month, we'll be taking this concept further with two new workshops exploring multi-agent workflows. The first will have participants simulate a team of AI agents by assigning each team member a specific role (Architect, UI/UX Designer, Developer, Tester) paired with a dedicated AI assistant. In the second workshop, we'll develop a framework to automate these multi-agent workflows and integrate them into familiar coding tools. Both sessions represent the natural evolution of our HULA approach - from single human-AI collaboration to orchestrating teams of specialised AI agents while maintaining that crucial human oversight.

If we keep human creativity and judgement at the centre while embracing what AI has to offer, we might just build better software than ever before.

Sources

A curated list of sources we referred to in developing the HULA framework: