The impact of artificial intelligence on the lives of software developers will equal, if not eclipse, the impact of the personal computer and the internet. In short, AI is a game-changer.

The writing is on the wall for many programmers, too. Meta's CEO Mark Zuckerberg said in an interview earlier this year: "Probably in 2025, we at Meta, as well as the other companies that are basically working on this, are going to have an AI that can effectively be a sort of mid-level engineer that you have at your company that can write code."

But, take heart! Human software developers still have a critical role in today's technology landscape -- it just won't be slinging the type of code that's been written a thousand times before. AI in coding will shine there.

Instead, programmers must take a different kind of approach to software development, and focus on analysis and creativity rather than structuring and writing code. Developers will still produce code, but that activity must go beyond declaring variables, writing expressions and manipulating logic.

Use AI to implement the dots you connect

At its simplest level, AI is akin to a giant word association framework.

Human consciousness can identify something without having a word for it, such as an infant recognizing his or her parent. AI, however, must first be given the words that identify things. For example, for AI to know about cats it must process millions of photos of felines against the word cat to gain that understanding.

Humans' ability to formulate thoughts in a nonlingual manner means that we can imagine something that does not exist, and once imagined, we name it. This is beyond AI's current capability. Put another way, the scope of AI's awareness is constrained to preexisting, documented knowledge. On its own, AI cannot expand its knowledge beyond its training data; if the training data is inadequate, so too will be AI's behavior based on that data.

For example, if you were to ask the AI site Perplexity, "How do you build an application to compete with Airbnb?," you might get a response such as the following, as I actually did:

To build an application to compete with Airbnb, follow these key steps:

1. Develop a solid business plan and identify your unique value proposition.
2. Assemble a skilled development team proficient in languages like JavaScript, Ruby and Swift.
3. Design a user-friendly interface that is intuitive and easy to navigate.
4. Implement essential features for your minimum viable product (MVP):
1. User profiles and authentication.
2. Property listings with detailed information and photos.
3. Search and filtering functionality.
4. Booking and reservation system.
5. Secure payment processing.
6. Messaging system between hosts and guests.
7. Review and rating system.
5. Choose a robust technology stack:
1. Frontend: React or Vue.js.
2. Backend: Ruby on Rails or Node.js.
3. Database: MySQL or MongoDB.
6. Cloud infrastructure: AWS or Digital Ocean.
7. Develop for both web and mobile platforms (iOS and Android).
8. Integrate third-party services for maps, payments, and notifications.
9. Implement security measures to protect user data and transactions.
10. Conduct thorough testing to eliminate bugs and ensure a smooth user experience.
11. Launch your MVP and gather user feedback for iterative improvements.
12. Continuously update and add new features based on user needs and market trends.
13. Implement a marketing strategy to attract both hosts and guests to your platform.

The steps above are not rocket science. Any developer who has worked on a team developing a large-scale web application would report the same as the AI response. In fact, the AI response is probably a synthesis of published articles and documents about software architecture.

As verbose as the response is, it lacks nuance. Notice there is a critical missing step: Determine your application's competitive advantage against AirBnB.

The question asked of Perplexity was not how to build a web application but rather, how to build an application that can compete with Airbnb. That subtle yet important difference requires human imagination to answer, an understanding of the opportunities to establish a competitive advantage over a given application. These "big picture" questions require imagination and human experience to answer accurately. They are the dots that must be connected to make your application work.

Once the big-picture question is answered and the dots to connect are known, using AI to implement each dot makes sense. AI is very good at reporting how to do things that have been done before. It's all a matter of asking the right questions in the right way, and learning how to create good prompts.

Learn to create good prompts

Think of a prompt as a natural language query against an AI model. As with writing any query, detail and efficiency count.

Consider the following SQL statement:

SELECT * FROM customers;

As an experienced database developer will tell you, the SQL above is a no-no. It asks for all the records from all the rows of the customers table, which is an expensive call to the database. There are few, if any, occasions when an application would require all of that data. Rather, an experienced database developer would write a query specific to the data needed, such as this:

SELECT first_name, last_name, company_name, date_added

FROM customers

WHERE date_added < '2020-01-01';

Notice the query above asks only for specific data -- first_name, last_name, company_name, and data_added -- and constrains the results to include rows with a data_added value for January 1, 2020. The updated query is not only more exact but also more efficient in terms of the processing burden placed on the database.

The same principles carry over to creating prompts; they need to be as exact and efficient as possible. Consider the following prompt submitted to Perplexity:

Write a class that adds two numbers together.

The result is shown below. Notice the Perplexity assumed that I wanted the code written in Python, which is a big assumption.

class Adder:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2
    
    def add(self):
        return self.num1 + self.num2

# Example usage:
# adder = Adder(5, 3)
# result = adder.add()
# print(result)  # Output: 8

Now, consider this more refined version of the first prompt:

Write a class in TypeScript that has a public method add that takes two numbers and adds them together. Make sure that the class only accepts numbers at runtime. Name the class Adder. Provide an example of usage.

The result from Perplexity is shown below:

class Adder {
  public add(a: number, b: number): number {
    if (typeof a !== 'number' || typeof b !== 'number') {
      throw new Error('Both arguments must be numbers');
    }
    return a + b;
  }
}

// Create an instance of the Adder class
const adder = new Adder();

// Example 1: Adding two numbers
try {
  const result1 = adder.add(5, 3);
  console.log('5 + 3 =', result1); // Output: 5 + 3 = 8
} catch (error) {
  console.error(error.message);
}

// Example 2: Trying to add a number and a string (will throw an error)
try {
  const result2 = adder.add(10, '5' as any);
  console.log('This line will not be reached');
} catch (error) {
  console.error(error.message); // Output: Both arguments must be numbers
}

As you can see, there is a big difference in the quality of those two responses. The prompt used in the first example is vague, and the response might or might not meet the needs of the programmer. The second example is much more precise: It defines not only the programming language for the response but also the constraints on the behavior of the code. All that's left is to test the code to make sure it works.

These prompts might be trivial examples, but they illustrate the value of using precise prompts to retrieve useful results. In fact, precise prompt construction is essential to make AI agents that return reliable results. Remember, prompts are how a programmer interacts with AI models. The more detailed the prompt, the more accurate and useful will be the response the model provides.

Testing AI-generated nondeterministic code is difficult

It's dangerous folly to expect anything or anyone to write perfect code from the get-go. Code needs to be tested. With AI-generated code, we must consider an additional aspect that increases the difficulty of testing: deterministic behavior and nondeterministic behavior.

Deterministic behavior is behavior that, given a particular set of inputs, always returns the same result. For example, an addition function is deterministic. When the inputs are the numbers 2 and 3, the result will always be 5. Nondeterministic is the opposite of that: Given a particular set of inputs, the results will vary each time a function is called.

You can use typical testing methods to test AI-generated deterministic code. This includes using automated testing methods. However, testing AI-generated nondeterministic code becomes difficult because even with consistent input the results might vary.

For example, consider asking AI to generate code for a function that provides a result based on the following statement: "Return the top five affordable vacation destinations for American tourists."

Logically, the inputs to the function are destination_count=5, currency_type=USD and tourist_type='American'. However, the result of that function will depend on various factors: the momentary conversion value of the currency at the time of the function call, the momentary preference for vacation destinations according to tourist type (in this case American) and the political situation in a given vacation locale. Surely you wouldn't recommend a vacation destination in the midst of civil conflict.

Given these dependencies, the results will likely vary on each call to the function. There is really no way to easily test the accuracy of the function's result based on quantitative analysis or even expected return value. One could test the function through human analysis, or using AI-driven analysis that emulates the logic of human analysis. Either way, the testing will be time-consuming, difficult to implement and potentially inaccurate.

To be sure, there are advantages to using AI to generate deterministic code: It is fast to write and straightforward to test. You can even use AI to create the code to test deterministic behavior. On the other hand, AI-generated nondeterministic code is harder to test given the variety of results that might occur.

The optimal use of AI in software development

AI in coding is a game changer for software creation and maintenance. AI can literally write code faster than a human can, and for most business situations the code it writes is of equal if not better quality than human-written code.

However, AI is not magical. It can only do what has been done previously, its ability to do innovative work is limited, and the code and business processes generated by AI lack nuance.

AI for systems design is another story, too. Humans can see the big picture, all the dots that need to be connected, and design systems accordingly. AI still has a way to go in this regard; so far it is very good at writing the code that implements those dots.

AI is evolving very quickly. As more data gets consumed and more robust large language models can do more complex tasks, particularly at the systems design level, there is a good chance that human endeavors will focus on extremely creative programming activities.

And no matter who writes the code, it will need to be tested. AI's ability to test complex systems, particularly those with a lot of nondeterministic behavior, is still a work in progress. Until AI makes the leap to become true thinking machines, human intelligence will still be essential in the software development lifecycle -- not for mundane tasks, but those that require extraordinary creative abilities coupled with a keen understanding of computer programming, probably at the Ph.D. level.

A recent MIT study found those who experienced the greatest gains in productivity using AI were new hires and entry-level programmers (27% to 39%), more than twice as much as senior developers (8% to 13%) whose performance was slightly better using AI.

In other words, the less complex the work, the more useful AI is for it.

AI in software development: A cautious conclusion

AI brings many benefits to the software development experience, but also significant risk.

As AI does more of the workaday tasks of software development, humans could very well lose the ability to understand what the AI-generated code is actually doing under the hood. This danger is particularly relevant to entry-level developers who, in the quest for job security, use AI to meet the relentless pressures of demanding deadlines. Their code might work, but what the code is doing and why it works is beyond their comprehension.

The situation mirrors the dangers of self-driving vehicles. After a few generations, humans will no longer need to know how to drive to benefit from the technology. Some people will know how to drive an automobile, but it will be a specialized skill, akin to horseback riding.

As fewer humans write the code and, more importantly, lose the ability to know how the code actually works, there will be no way to control AI. No software developer (or anyone else) should want that situation to occur. The purpose of AI is to be our helper, not our master. We need to beware.

Will software developers be replaced by AI? In short, no -- there will always be a place for humans in the software development lifecycle. The challenge moving forward is that to thrive, human software developers will need to be very smart, analytical, experienced and extraordinarily creative. Developers will need to imagine things that have yet to exist or in unexpected ways -- because if it's been done before, AI will be able to do it again, faster and at lower cost.

Bob Reselman is a software developer, system architect and writer. His expertise ranges from software development technologies to techniques and culture.