No posts for a wee while

Mike's Notes

I was on holiday for the last few weeks and am back now. There will be no blog posts, newsletters or meetings until Pipi Core is back up and running.

Update 27/05/2026

Lots of surprises. Making rapid progress. The peace and quiet are bliss.

Update 31/05/2026

The problem and solution are how things are named. Pipi auto-generates thousands of code names using multiple pattern languages, and all the naming conventions require many minor fixes for several unexpected reasons after migrating from a developer laptop to a production server environment. Everything else is absolutely fine.

Other naming problems are also being solved now, including:

• The rapid development of Boxlang by Ortus has brought forward another challenge. Pipi 10 will be migrated to run on top of Boxlang in 2027 to support multiple languages, including C++, CFML, COBOL, Go, Java, JavaScript, PHP, Python, Rust, etc.
• Future integration with cloud-based LLMs.
• Future integrations with Office365, Google Workspace, Zoho, LibreOffice, etc.

The common solution is to create standardised naming systems that are simple, stable, robust, schema-based, versioned, self-documenting, and extensible to meet unanticipated future needs.

This is done by replacing code-based naming rules with database-driven ones that can be easily edited in the future via an admin UI.

90% of these names are internal, hidden in the closed core, and how they work and what they are will not be discussed here. The rest will be publicly and fully documented as part of the open-source workspaces for developers to work with.

Update 02/06/2026

I'm changing the disclosure boundary between the Pipi closed-core and open-source workspaces. Previously, "disclose everything unless there is a security reason not to". This is now changed to "disclose on the basis of need to know".

Closed-core accounts for 90% and open-source workspaces for 10% of lines of code, databases, etc.

This will reduce the documentation burden, given Pipi's vast scale. So, the open-source workspaces will be fully shared and documented on GitHub, etc, without restriction. This includes;

• Standards schema
• Ontologies
• Parameters
• Laws of physics
• HTML + CSS
• Algorithms
• Module DDD models
• Workflow diagrams
• Documentation
• API schema
• UI code
• etc

This also means some existing technical documentation about the closed-core will become hidden and only available internally.

Update 07/06/2026

Pipi Core is the IDE used to edit Pipi Core (AKA: which came first, the chicken or the egg?). Temporary UIs have been created and are being used across multiple engines to edit the names in use. This is much faster than directly editing data, which had to be done initially. The next step will be turning auto-generation back on. Once that's done, temporary UIs will be used to build permanent UIs. More automation will then be enabled via the UIs, and so on as Pipi Core builds itself with a human in the loop.

Update 08/06/2026

The list of code cases available to use now for auto-generated naming, I/O translation, etc with examples, includes;

• camelCase: userProfilePicture
• kebab-case: user-profile-picture
• PascalCase: UserProfilePicture
• snake_case: user_profile_picture
• SCREAMING_SNAKE_CASE: USER_PROFILE_PICTURE
• Train-Case: User-Profile-Picture
• flatcase: userprofilepicture
• UPPER-CASE-KEBAB-CASE: USER-PROFILE-PICTURE
• Sentence case: User profile picture
• Title Case: User Profile Picture
• middot·case: user·profile·picture
• dot.case: user.profile.picture
• UPPER CASE: USER PROFILE PICTURE
• lower case: user profile picture

Update 12/06/20026

Checking that these changes to variable names and internal messaging do not clash with the Gödel Machine.

Update 17/06/2026

The DevOps Engine (dvp) has unexpectedly proven to be critical to solving this puzzle. Mostly fixed last night. Watching the rather excellent live Google talk: Beyond the GPU: Maximizing goodput with self-healing AI infrastructure, this morning, has given me valuable insights into fixing the rest from looking at Google HPC YAML files. 😎😎 Sometimes insights come from the strangest places.

Resources

• https://www.blog.ajabbi.com/2026/04/agents.html
• https://sah.org/2017/07/18/medieval-masons-and-gothic-cathedrals/
• https://share.google/aimode/VcqtuYrDn958q9Fej
• https://en.wikipedia.org/wiki/Hyperphantasia
• https://modern-cfml.ortusbooks.com/cfml-language/queries
• https://en.wikipedia.org/wiki/Letter_case#Use_within_programming_languages
• https://www.blog.ajabbi.com/2023/12/george-ellis-and-emergence.html
• https://www.blog.ajabbi.com/2026/02/the-dream-of-self-improving-ai.html
• https://knowm.ai/blog/kt-bit-catalog/
• https://cloudonair.withgoogle.com/events/beyond-gpu-maximizing-goodput-self-healing-ai-infrastructure

References

• Reference

Repository

• Home > Ajabbi Research > Library >
• Home > Handbook > 

Last Updated

17/06/2026

No posts for a wee while

By: Mike Peters

On a Sandy Beach: 15/05/2026

Mike is the inventor and architect of Pipi and the founder of Ajabbi.

I was on a no-coding holiday for the last few weeks to clear my mind, and it has been great, and back on the job today.

Suspended

Until the closed-source Pipi Core is back up and running 100% on autopilot, 10x faster, the following are suspended.

• New posts "On a Sandy Beach
• All newsletters, including the weekly Friday Report and the monthly Ajabbi Research Newsletter.
• The fortnightly online Open R&D meeting.

Rapid refocus

• A new developer area with five coding screens, designed to be more productive for hypervisual learners.
• A better library has been set up for my A4 drawings in ring binders, the many reference books I use, and more bookshelves are on the way.
• The server rack has been moved to a better location.
• The light levels have been adjusted.
• A big office tidy is almost done. An office-work-only desk has yet to be set up with a cat bed included.
• A separate area with no screens for the happy cat, coffee, music, reading and drawing.

Less is more

Minimise screen time to be more productive at work. The new setup is also much less tiring.

Get the job done

The good thing is that, with a holiday and lots of drawing, I now have mental clarity about what needs fixing and how to fix it. Mainly, quite delicate changes here and there, organised into a list of steps. Now, I need to concentrate on one thing only: go as fast as possible, without meetings, post-deadlines, phone calls, or other distractions.

How

1. Use an AI workforce

Be the architect, and AI fills in the dots to make it happen.

Use Google Search AI mode (Gemini) to generate 99% of the code in one-page chunks (including references) to copy and paste, then manually change the variable names and SQL. Careful, test everything, resulting in 100x faster progress. Know how everything works and rapidly raise personal skill level.

2. Then build a cathedral

Make a wooden scale model of a cathedral for the builders. Google Search AI mode (Gemini) makes each brick, and Pipi Core assembles the bricks into floors, arches, walls, and vaults...

Speed is king

With the 100x coding productivity gains from Google Search AI mode (Gemini), plus the 10x10x10x speedup of Pipi Core currently underway over the next few months, what previously took a year will be done in hours and better.

Phase transitions

Once these initial migration issues from laptop to server are resolved, further transitions can be anticipated as the number of engines rapidly increases beyond 20. Increasing the number of engines slowly changes the whole system's behaviour from deterministic to probabilistic and adaptive.

Here is a partial list of transitions expected as the number of engines increases from 0 to 200. The actual numbers are a bit of a guess.

• 20 engines enable Pipi 9 Core in a simple, deterministic structure.
• 40 engines enable a workspace with a UI for administering Pipi Core.
• 60 engines enable self-generation of user documentation.
• 80 engines enable REPL and IAC (infrastructure-as-code).
• 100 engines enable Workspaces for different user accounts.
• Different Pipi 9 editions are made with the same engines, which recombine differently in response to the external environment.
• And so on until...
• 200 engines self-organise into a multi-layered complex fluid structure with probabilistic behaviour and emergent properties, as engines also act as agents.
• 200+ engines enable Pipi 10 to interact with externally cloud-hosted LLMs, combining the very different strengths of both.