A few weeks back, when I first wrote about the triad of tech ‘languages’ (Markdown, JSON and Python) that I’m calling the Golden Triangle, I definitely understood it conceptually.
JSON structures data. Markdown provides order and consistency when data and content is output. Python carries out actions. Clear and simple.
But as I got deeper into this and started thinking about and experimenting with what this would look like for PerformaGo, I realised something important. The triangle isn’t just a convenient way of describing three bits of technology. It’s the actual choreography happening behind the scenes every time a GPT gives a clean, structured, useful answer.
And nowhere is this more obvious than when someone is using a GPT as a real performance-support tool.
A simple request brings a mini-ecosystem to life
Here’s an example that I hope really helps illustrate what I mean. Let’s say a user types in the following request for workplace help:
“Show me how to complete the quarterly GDPR compliance audit in the new CRM system.”
On the surface it’s a straightforward performance-support request. A request that is asking to see the consistent set of steps that need to followed in that system in order to complete the audit.
Of course, this is the kind of thing L&D teams have been producing job aids for since job aids were invented. But inside the GPT this one sentence triggers the entire Golden Triangle into action.
JSON quietly gets the ball rolling
Because this procedure can’t be fluffed and the exact same steps need to be provided each time they are requested, this is an example of deterministic content.
This means it needs to be stored in a database to ensure it is always provided ‘as is’ and not subject to the generative variations that might appear if it were just stored in the GPTs knowledge base.
Enter JSON, ready to receive the structured data from the database. Data that will ultimately populate a procedure table. So, JSON will hold things like:
- the steps
- the field names
- any conditions or variations
- error states (“If the date field is greyed out…”)
- the user’s role (administrator vs. team member)
All contained in tidy labelled buckets. Exactly the kind of structure a machine can make sense of.
Python picks up the ball
This is the bit I didn’t fully appreciate until recently. Python really is the operational engine of the whole thing. It runs the logic that assembles all these labelled buckets into a coherent, relevant sequence of steps.
Markdown gets it over the finish line
Finally, Markdown manages the part we actually see. It turns everything into something readable. In this case, a two-column procedure table that provides a neatly formatted and easy to follow set of steps for a user. Exactly what performance-support content should be like.
So, there you have it: the response to a single user request, quickly and elegantly assembled by the three corners of the triangle.
Assembling on the fly
From the user’s perspective, the GPT looks like it’s just serving up a ready-made job aid. In reality, it’s assembling one on the fly, by leaning on the three incredibly simple, incredibly powerful components of the Golden Triangle:
- JSON to give it structure
- Python to give it capability
- Markdown to give it output clarity
Together, they form a miniature production line — a system at the heart of your custom GPT that turns data and content into something finished and useful.
Two final thoughts
A couple of important points to conclude.
- First, although the elements of the Golden Tringle are central to the success of your custom GPTs they are not the only elements involved. Prompts, knowledge bases and databases all play an equally important role.
- Second, as a user of PerformaGo, you won’t need to become an expert in JSON, Python and Markdown to create custom GPTs for your learners. The tools of the Golden Triangle will hum away quietly in the background.
Coming next…
Finding out about the three elements of the Golden Triangle and understanding how they apply to the building of PerformaGo has been one of many key moments for me since seriously starting this AI-focused journey in July.
But as we approach the end of the year, I’m starting to realise that my own journey is but one small example of much larger, rather extraordinary shift that is happening around me.
AI isn’t only about changing how systems work — it’s also about changing who gets to participate in creating them.
And that’s the thread I want to pick up next as I close out the year: The Great Uncoding – the quiet dismantling of the old boundaries around who gets to build the systems.
Until next week…
