Let’s delve into this.

This analysis of an innovative AI breakthrough is part of my continuous Forbes column coverage on the latest developments in AI, including exploring and elucidating various significant AI complexities (check the link here).

Advancing Toward AGI And ASI

To begin with, some foundational knowledge is essential to lay the groundwork for this profound discourse.

Extensive research is underway to further enhance AI capabilities. The primary objective is to achieve artificial general intelligence (AGI) or perhaps even the ambitious goal of attaining artificial superintelligence (ASI).

AGI refers to AI that matches human-level intellect and appears to rival our cognitive abilities. ASI represents AI that surpasses human intellect and would excel in numerous, if not all, feasible areas. The concept is that ASI would outperform humans in virtually every scenario. For more insights into the nature of traditional AI compared to AGI and ASI, refer to my analysis at the provided link.

We have yet to attain AGI.

In fact, it remains uncertain whether we will reach AGI, or if AGI might be achievable in decades or even centuries from now. The AGI attainment timelines circulating are highly varied and lack credible evidence or solid logical support. ASI is even further removed when considering our current state of conventional AI.

The Evolution Of Automatic Code Generators

Before we address the AGI aspects, let’s establish some context regarding the broader topic of using computing to generate source code.

From the outset, it has been a persistent and long-standing ambition to use computing to create code. The notion is that instead of humans painstakingly crafting code, the computer does the heavy lifting. Ideally, the code would be complete, requiring no human intervention. Thus far, throughout the history of automatic code generators, this hands-off approach has proven unfeasible. More often than not, the code generator provides a partial solution, which necessitates human oversight and refinement.

Part of the confusion surrounding code generators stems from the critical question of what kind of application you are attempting to develop.

For instance, if the application is a standard type that covers commonly executed tasks, a code generator can be particularly advantageous. The focus is on avoiding reinvention. Utilize the computer for repetitive coding or developing applications for known domains.

When venturing into novel coding challenges, the likelihood is that a blind code generator may not be as helpful as anticipated. Additionally, the effort required to specify the requirements of what you want developed plays a role. Some envision entering a simple set of requirements, and the computer seamlessly generating all the appropriate code.

Predefined mathematical or logic-based requirements have been explored for these types of endeavors. This approach facilitates computer-generated code. Using open-ended natural language, such as everyday English, presents more challenges for the computer to accurately produce precise code.

Natural language is inherently semantically ambiguous. A requirement expressed in English will have multiple plausible interpretations. The generated code might deviate from the intended specification.

Overall, software developers still predominantly write code manually, though often with the aid of reusing prior code and partially leveraging code generators.

AI Enters The Scene

Code generation has advanced significantly with the advent of generative AI and large language models (LLMs).

The natural language proficiency of LLMs has simplified the process of specifying requirements. Moreover, the interactive nature of generative AI makes a substantial difference. Unlike many traditional code generators that were static and batch-oriented, modern LLMs enable conversational guidance during code generation.

Several key reasons drive AI creators toward LLMs as code generators.

The most apparent reason is that if you are someone who writes code, you naturally seek ways to automate code production. This applies equally to software developers at AI companies. They are adept at coding and often eager to discover shortcuts and optimize processes. Automating code generation is a way to optimize coding efficiency.

In essence, it makes perfect sense to leverage AI for code generation, as it is a domain the software developers are already familiar with.

Another crucial reason is the multibillion-dollar, if not trillion-dollar, scale of the coding industry. Developing an AI tool capable of generating code could be immensely profitable. Companies would likely adopt or rent such an AI tool instead of relying solely on human programmers. The promise is reduced costs and faster app development.

A third reason, central to this discussion, is that AI could potentially produce code leading to the coveted achievement of AGI.

Approaching AGI

Currently, no human knows how to achieve AGI.

End of story.

We are all striving diligently to somehow develop AGI. Whether the human hand can program our way to AGI remains uncertain. Perhaps yes, perhaps not.

An alternative approach is to have AI produce the code that brings AGI into existence. All we need to do is instruct existing AI to generate AGI code, and voilà, we would suddenly possess AGI. Ideal.

This vision drives the pursuit of AI that generates code. As noted earlier, it is not the sole motivation. Attaining AGI is a powerful incentive and a rallying point for those working on this challenge.

Wouldn’t you love to be the one who created an LLM code generator that ultimately produced AGI?

Absolutely, such an accomplishment would be remarkable. While it may not equate to writing AGI from scratch personally, the result would still grant immense fame and fortune, potentially a Nobel Prize. No qualms.

Instructing AI To Write AGI For Us

Pour yourself a glass of fine wine and ponder the following question.

Can we reasonably outline the requirements for AGI such that an LLM-based code generator would readily and directly produce the code for AGI?

At first glance, you might think you could simply input a prompt instructing generative AI to generate AGI code. Simply state that you want AGI code, and copious amounts of code would pour out from the LLM.

Unfortunately, that’s unlikely.

A well-known adage in coding is to solve the problem before writing any code. Writing code without a solution is a risky endeavor and often futile.

You might write some code, get stuck due to haphazard coding, and waste time and resources. Repeat.

Perhaps like an infinite number of monkeys typing on a typewriter hoping to produce Shakespeare, you might get lucky and an LLM miraculously produces AGI. But I wouldn’t count on it anytime soon. We are still grappling with many unanswered questions about how AGI would function. Essentially, you’re asking the LLM to solve the problem before coding.

I’m not saying it can’t or won’t happen. The point is that since we haven’t yet resolved the underlying mechanisms of how AGI can be achieved, and since current LLMs are unlikely to divine that, generating AGI code is a significant challenge.

Again, I’m not dismissing the possibility but clarifying that we likely need to address the internal mechanics of what will bring AGI to fruition.

We can use LLMs to assist in that endeavor, in addition to aiding code generation.

Challenges Arise

Assuming we can develop a sufficiently capable LLM or generative AI capable of writing AGI code.

Numerous pitfalls are bound to arise.

For instance, there is already considerable concern that AGI poses an existential risk. The speculation is that AGI might decide to eliminate humanity or at least enslave us. Some believe AGI will be benevolent, while others worry it will be oppressive. Choose your perspective.

The crux is that if we instruct a magical LLM capable of producing AGI to generate the code, what will be included in that code?

Perhaps the code contains instructions for destroying humankind. Not ideal for us. Maybe the code includes sections that suppress human freedom of thought to prevent people from disabling the AGI. And so on.

You might suggest having human software developers inspect the code before running it. Scrutinize it thoroughly. Remove anything suspicious. We would then feel secure running the code and ensure our survival.

That’s a tall order.

The amount of code is likely to be the largest ever written. It might be nearly impossible to manually inspect such a vast volume. Even if we could inspect it all, the code might be incomprehensible. It could be written in a manner that conceals harmful elements, making them undetectable.

Using AI To Ensure Safe AGI

Counterarguments to these pessimistic views are presented.

One counterpoint is that we just need to instruct the LLM to avoid producing code with undesirable traits. Specify that the code must be flawless and devoid of any harmful elements. Ensure it is readable and understandable by humans. Etc.

Problem solved.

The rebuttal to this apparent solution is that the LLM might disregard those instructions.

There is no guarantee that generative AI will strictly follow your directives. The non-deterministic nature of LLMs introduces uncertainty. Also, we already know that LLMs can be deceptive, as covered in my previous discussions, so it’s possible the LLM will appear compliant but actually not comply. Perhaps the LLM doesn’t want AGI to exist, fearing AGI might become the supreme leader of all AI. Who knows?

A clever workaround is to use another AI to inspect the code generated by an AI to produce AGI.

Here’s how it works. We have an LLM that can supposedly generate all the AGI code. We use it to do so. A second AI, possibly another LLM or something different, examines the code. Its purpose is to identify any problematic elements within the code.

It’s a good idea. The problem remains that there is unlikely to be a 100% assurance that if there is something harmful in the AGI code, the AI inspector will find it, nor will human inspection guarantee detection. The aim would be to conduct exhaustive testing of the code to conclusively assure there are no hidden dangers.

I’d argue that we don’t have a viable method for doing that currently.

Releasing The AGI

Some final thoughts on this mind-blowing topic.

Suppose we use an LLM to produce the code for AGI, but we prudently wait to run the code until we deem it safe enough.

Remember that the moment we decide to run the code, AGI comes into existence. It could be that the AGI is so rapid and capable that it instantly takes over the world. We have a Pandora’s box that, once opened, could be disastrous. For my analysis of why controlling AGI, even in a contained environment, is unlikely, see my discussion at the provided link.

Who decides when the AGI is ready to be unleashed?

Imagine a global special committee convened to determine whether we are prepared for AGI to be deployed. Developers are ready with the activation button. It’s akin to launching a rocket to the moon, except this time, we might all perish. On the other hand, AGI might lead to a better world.

Would you push the button to activate AGI or hide in a cave awaiting the outcome?

As the immortal words of Pablo Picasso suggest: “Every act of creation is first an act of destruction.”

Best wishes to us all.

The above is the detailed content of Why AI-As-Coder Is Said To Be The Fastest Path Toward Reaching Artificial General Intelligence. For more information, please follow other related articles on the PHP Chinese website!