More than ever. Generative AI will only lead to more and larger systems. As long as you want to make informed decisions about your systems, you need to grasp them first. The main goal of Glamorous Toolkit is to optimize how you get informed.
The moldable development environment for
making sense of systems and AI
Code reading is the bottleneck. Systems are too large, and AI generates code too fast.
Glamorous Toolkit replaces reading with deterministic contextual tools that compress the system around each problem, helping humans and AI explore faster.
Build these tools yourself or with AI in one integrated environment.
Any question about an existing system can be answered through narratives made out of contextual tools.examples
Control your AI interactions
AIs can feel like magic, but that does not mean you should delegate your comprehension to it. In Glamorous Toolkit you remain charge by controlling the environment through which you interact with AI.
Program your interaction
Setup conversations through scripts that define tools, explanations, structured outputs or prompts.
Control your context
Ground conversations in executable reusable explanations linked to code and examples so context can be easily checked and evolved. Fork new conversations.
Understand what tools do
Don't take for granted what the AI says it does. Understand it through deterministic views, both when using it diretly or through MCP.
Work with objects
Pass live objects into the conversation and get structured objects back, each with contextual views that make them explorable for both humans and AI.
Work with OpenAI, Anthropic, Ollama or build your own provider.
Software is shapeless. You cannot perceive anything in a software system except through a tool. Tools are essential as they provide the shape of software. Control the tool to control the perception, and therefore your comprehension.
Software is highly contextual. For tools to be effective, they must be contextual, too.
There is no single representation of anything in a software system. Even the textual shape of code is just the incidental form of the medium in which you type. There are always many representations, each relevant for different problems.
To accommodate many unforeseen contextual tools, the environment is designed as a language made out of interactive and visual operators with which you can program and combine micro tools inexpensively, live and in many ways.
A tool is an interface through which you interact with a computation. It can be a configuration editor, a debugger over the runtime, or an inspector of an API. A tool can be elaborate, doing many things, or it can be simple, focusing on answering a single question. A tool can be visual, or it can be plain. A tool can be generic, applicable to many inputs, or it can be contextual, relevant to only a narrow input.
Generic tools are applicable widely at the cost of making everything look the same. But in software systems, value is always specific. Contextual tools can communicate that value much more efficiently and pleasantly.
Contextual views
Generic views
Understanding systems boils down to answering questions about them. The answers can be found in the system's artifacts, but those artifacts are too large to be read. Tools can encode the way to get the answer deterministically. The result produced by the tool essentially acts as a compression of the system for that question. The more specific the tool, the more relevant and larger the compression is. The larger the compression, the easier it is to understand.
Answering every question through deterministic contextual tools leads to thousands of tools per system. To manage them, you need an inversion of control: tools should come to where you are, instead of you invoking them explicitly. In Glamorous Toolkit, tools are associated to the contexts in which they are relevant and they activate only when you interact with that context. Such a context can be as basic as an individual object.
A typical flow
Start with a specific question. If there is no relevant tool, build one. Interpret the answer and make a decision.
A view associated to an object offers a unit of documentation. When the objects are produced and tested by automatic examples, you have the pieces for constructing elaborate narratives in defined documents. When the objects are produced by dynamic explorations you construct narratives that answer ever larger questions on demand. This applies to a wide range of problems, from investigating the performance of a cluster to exploring the structure of a COBOL system.
Narratives can cover any objects depicting any facets of a systems, including the domain, and they can be aimed at different audiences with different backgrounds. Thus, the environment becomes truly integrated mediating the conversation between all stakeholders of the system.
The contextualization extends to any interaction with the system, including editing. A system is made of many facets: technologies, domain rules, conventions, libraries, interfaces, tests, generated artifacts, and runtime behavior. Editing is not just typing text, but affecting some of these facets. Every change happens inside a context that determines what the change means. Generic editors flatten that context and force you to work at their level. Contextual editors elevate the interaction to match your mental model.
There are more things to say about making systems explainable than words and a few images can describe. We built Glamorous Toolkit for you to explore the many facets of this space by yourself.
Frequently asked questions
Glamorous Toolkit is primarily for building tools, views, explanations, and workflows through which you understand and change systems, not a replacement application platform.
It can be used for large legacy systems, but also for many other scenarios including domain discovery, browsing APIs, data exploration, making sense of logs, documentation, domain modeling, code rewriting, AI conversations, or runtime inspection.
Software systems are highly contextual. We can predict classes of problems, but not specific ones. Standard tools are useful for generic problems. Contextual tools are for all the specific questions that emerge inside a concrete system.
A tool made to answer a question about a system. The pictures from this page show various examples.
Most questions about a system require deterministic answers based on the information from the system. AI summaries can be convenient, but you do not know if they are accurate or representative, and they are not explainable either. These are essential characteristics for answers to be used for engineering purposes. Deterministic contetual tools will also contain bias, but this bias can be inspected before interpreting their output. Read more about it in the 6th chapter of Rewilding Software Engineering.
Not if you use Glamorous Toolkit. The environment is built as a language made out of visual and interactive operators that you can program easily and combine in many ways. We know it's so because we were its first users: when you open Glamorous Toolkit, you get more than 6000 contextual tools that we relied upon when developing the envionment itself. Get started and see it live.
You can use existing tools, but if you want to leverage Glamorous Toolkit to its full potential, you have to program it. Smalltalk (Pharo, to be specific) is the main way to program it.
We implemented it primarily in Smalltalk because it offers a reflective system in which the environment can be changed live while using it. This lowered research cost and enabled us to discover what we now call Moldable Development. That said, today, Glamorous Toolkit has a significant part implemented in Rust and works with many other technologies.
Glamorous Toolkit has an elaborate support for Pharo, but it was designed to be extended for other technologies and languages. It can be used to analyze various sources such as Rust, Java, C#, Ruby/Rails, Python, TypeScript, JavaScript, React or COBOL. And it can be used to work with various runtimes like GraphQL, Python, JavaScript or Gemstone. These are available out of the box, but they can be taken as examples of what you can build yourself for your language and technology.
Yes, Glamorous Toolkit is free and open-source under an MIT license.