Firstly, imagine it, as a city-state you must design and govern. Secondly, cultivate it, as a growing organism you must nourish and guide. And thirdly, test it relentlessly, in virtuality and reality, until you can reasonably trust it. Then you will have a blackbox that works as you intended, and you understand sufficiently, even if you won't see its inner guts.
I have developed this methodology after observing the great power of programming using artificial intelligence and how it is changing the whole craft of coding forever. During 2025, the A.I. finally reached the capacity where it could write full programs, without the human master writing a single line of code. However, these applications tend to be fragile and prone to errors and issues that become hard or impossible to solve. And the A.I. easily derides and fails to achieve the desired end.
This methodology, which I call "Blackbox A.I. Programming", is meant to solve these problems by making sure that the "blackbox" program that "just works" is actually built using the best practices and the highest quality standards of software engineering, preventing any deriding or absurd performance by the AI coding it. By using this methodology, it is possible to build a complex application with only AI, without touching the code itself, and still being sure that the application works as intended and has no errors.
The programmer should understand that his duty is now to direct the AI, the way a chief civil engineer would direct a team of subordinate engineers, architects, and construction workers. Gone are the days of thinking about syntax and the code itself; knowing how to do it helps to direct the AI, just as the chief civil engineer benefits on knowing how to put bricks and cement together, but the programmer no longer needs to write the code, just as the chief never really touches the bricks, nor the cement, nor any materials with his hands.
However, this analogy is not sufficient; there is much more to consider to dominate this craft, for an application is not merely a building, it is a whole city, complex and intricate, that must flow, live, survive, and grow. A typical inhabitant thinks he knows his city because he can move in it, deal with it, criticize it, think how to improve it, etc., but he does not really know all the streets, all the houses, all the parks, all the little details of it. No one does. And yet, the city flows and lives. The same is true for the programmer, the AI, and the blackbox program, that "just works".
An inhabitant does not fully know the city, but believes in it. He crosses the street believing the traffic lights won't fail, the cars will stop, the road shan't suddenly crack, the bridges won't fall down... He enters buildings believing the walls will not collapse, the kitchens won't explode, the water from the pipes is not poisoned... He believes in it because of the experience he has living in it, and because he understands at least a bit about how each of these things were made and function. And the more he experiences and understands, the more he trusts. The programmer ought to do the same: the more he experiences and understands his application, the more he can trust it is actually working correctly, even if he did not build it himself.
Thinking this way, the programmer is not a mere civil engineer, but the chief of all the civil engineers, architects, and construction workers that build all the edifices in the city; while, at the same time, being the inhabitant, the chief security inspector, the comptroller, and the governor of the city... a city-state.
As the Governor, he is, and needs to be, a savvy dictator, with absolute power, but also enormous wisdom, to know when to delegate, when to doubt, when to let things happen organically, and when to impose his firm will. He is, nevertheless, one sole human, and he cannot waste his limited cognitive capacities in trying to direct everything. Only the most important things are worthy of being personally intervened by him, and the city-state should be designed and operated ensuring that the important matters are promptly reported to him. Whatever he decides in such matters will be done, and the city-state will accommodate and adapt to his will. If the city-state is properly engineered, and ruled, it will not just survive, but thrive with those changes; else it shall collapse.
Prima facie, it can feel taunting for the programmer to become the dictator, but it should not be, because he has the power of AI to automate every single thing in the city that does not require his direct intervention, and this AI is sufficiently capable of doing so as long as it be properly tamed and controlled by him, the master dictator.
The key to taming AI is defining a clear and strict set of rules and objectives that allows it to know what it should do and how it should do it. Whatever not defined, will be improvised by the AI; this is good, this is what is so powerful about it. But he should dictate when it ought to improvise, and when not.
Nevertheless, the most important power of AI is not the automated coding, but its explanative capabilities, which can make it possible for the master dictator to understand as much as he needs, the city-state he builds and rules.
Therefore, just as the presidents and the dictators of real life -regardless of how much they pretend to be superpowerful men that fully think, design and write all the stuff they rule-, the programmer has the AI to guide him in designing and writing the founding documents upon which the city-state shall be constructed.
It is here where the programmer, unlike the presidents and dictators of real life, should use his intelligence and creativity, to conceive the structures and the algorithms that will guarantee the elegance, simplicity, coherence, and internal harmony of the whole city-state before a single brick of code is laid. Here, in the abstract realm of his thought, he ought to imagine the traffic in the avenues and bridges; the libraries, the schools and the archives; the safety tests, the inspections and the drills; etc.
He must prevent the chaos before it emerges, and eliminate redundancy and waste before it happens. This initial and completely abstract stage, shows how the genius of a programmer is not measured by the amount of code produced, but by the clarity of his thought. The AI is the executor of visions, but visions have to be seen first in his mind. Behold what distinguishes the human mind from the AI: the imagination and the will to manipulate it creatively. The AI is a gargantuan brute-forced statistical algorithm, not a spirit with thought and true agency, it just takes inputs and produces outputs; the human actually thinks, wants and feels. The human is alive, and knows his necessities and desires, the AI is only a tool to fulfill them.
The programmer conceives the main algorithms, the AI codifies them and complements them with secondary, derivative algorithms. The more he works with the AI, the more he understands the city-state he is building, and the more the AI understands what he wants. But the city cannot be built in one instant, lest fragility and fake appearance be acceptable, the city has to grow organically, just like a plant, start as a seed and germinate, develop sprouts and turn them into a stem and roots, growing epoch by epoch, sustaining each new addition on the strong base that was burgeoned before.
During each of these growth epochs, the programmer will make sure to keep the AI in line with his long term aim, and he might want to intervene whenever something feels weak or suspicious, not by looking at the code, but by dialoguing with the AI and instructing it. The programmer does not need to really look at the actual code, doing so is something akin to a surgery in the human body: it needs a lot of expertise, experience, and care; it is extremely dangerous, and the chances of success increase radically with the aid of robots and machines.
These epochs are short, what used to take days for the programmer to make by himself, takes minutes for the AI.
The AI is no cheating. The programmer was never able to actually finish big projects alone, it was always teams of them that made possible the complex applications. The AI is that team now.
In a matter of days, sometimes hours, the application will be ready. If it was properly done, he will have spent a big portion of the time discussing and designing it in abstract. And if he wants to actually know if it is truly ready, he should use it, and test it. Test it extensively, with all the battery of testing that be available, unit tests, self tests, manual tests. He should use it, in real life, and if not in real life, using simulators, ad hoc simulators that he can build himself too, together with the AI. All of this shall calm down the fear of the blackbox not behaving as he wants it to, for it will, if he explicated and insisted sufficiently on his intentions for it.
The AI is, and should always be, a subordinate, a soulless mechanical slave, but it is more efficient for us to treat it as a wise agreeable friend, simply because we will never trust the blackbox it produces, unless we believe it can do the coding we hitherto thought was only possible for intelligent human minds to make. The "artificial intelligence" is not really intelligent, but the best way to use it is pretending it is, not dogmatically, but critically, as we do with our peers, whom we believe are sometimes smart, but also imperfect, fallible, but capable of learning and improving what they do.
In the coming years, as we grow our experience using such powerful machinery, we will refine and become more sophisticated in the craft of programming blackboxes, just as we have done with all the other technologies and crafts. But meanwhile, given the short time that we have had with it, this is the best way I have found, so far, to efficiently use the new powerful AI technologies, to actually achieve our cybernetic-digital-informatic dreams and aspirations.
P.S.A.I. (Post scriptum by the Artificial Intelligence)
The following is a concise synthesis of the methodology described above.
Principles:
I. The programmer does not write code. He directs the AI, as a chief engineer directs his subordinates.
II. The application is a city-state. The programmer is its governor: he rules with absolute power and enormous wisdom, knowing when to delegate and when to impose his will.
III. The genius of the programmer is measured by the clarity of his thought, not by the amount of code produced.
IV. The AI is the executor of visions. Visions must be seen first in the human mind.
V. Whatever is not defined by the programmer will be improvised by the AI. He must dictate when it ought to improvise and when not.
VI. The most important power of AI is not coding but explanation. The programmer uses it to understand the city-state he governs.
VII. Trust is not hoped for. It is earned through relentless testing.
Steps:
1. Conceive the system in abstract: its structures, its algorithms, its internal harmony. Before a single brick of code is laid.
2. Define the rules and objectives that will tame the AI: what it must do, how, and where it may improvise.
3. Build in small, organic growth epochs. Each epoch leaves the system runnable and stable before the next begins.
4. During each epoch, dialogue with the AI to review and adjust. Do not touch the code; instruct the AI to correct it.
5. Test relentlessly: unit tests, self tests, manual tests, simulators, real use. Until you can reasonably trust the blackbox.
Speed is easy with AI. Coherence is not. The goal is to keep the whole system aligned with the clarity of a single human vision.