The Future is Now: Integrating AI in Software Development

In the world of software development, the rise of artificial intelligence (AI) has been nothing short of revolutionary. As programmers, we’re always on the lookout for tools that can streamline our workflow and boost productivity. AI offers exciting possibilities to assist us in writing better code, automating tasks and even inspiring new ideas.

However, while AI holds tremendous promise, it’s crucial to approach its use with care. Like any tool, AI has limitations and potential pitfalls that demand cautious navigation.

So, let’s embark on a pragmatic journey through the realm of AI in programming and app design. Together, we’ll uncover the true value of AI as a powerful tool in your arsenal and learn best practices for leveraging its potential responsibly.

What You’ll Learn:

• The potential for using AI in app development.
• Effective strategies for collaborating with AI.
• Pitfalls to avoid when using AI in app design.

In this article, you’ll learn some ways that you can use AI to strengthen your coding abilities — along with real-world examples from my own app-building experience. You’ll also learn about potential pitfalls to be aware of when you use generative AI as a coding tool.

Specifically, you’ll learn about three powerful ways to use AI in software development:

1. Planning your app.
2. Improving your code.
3. Designing icons and artwork.

It’s time to get started!

Brainstorming App Ideas and Features

Before you write a single line of code, you need to know what you’re building. But where do you begin? Here’s where AI comes to the rescue. It can be extremely helpful in the early stages of app creation.

Note that using AI for design does not replace conducting your own research amd user testing. Rather, it serves as a tool to overcome “writer’s block” and help you focus on the right things.

As you use Ai in this capacity, be aware that it may offer unsound advice or propose generic and uninteresting ideas. For unique and captivating user interactions, you meed a human touch.

Suppose you want to build an Astrology app. Your first question to ChatGPT may be something like this:

This is a great start! It gives you a few ideas to pursue. However, being an MVP, not everything on this list will make it to version 1.0 of the product. You could ask ChatGPT to narrow things down, but it’s easy to see already that the most important feature is horoscope generation.

Talking to the AI should be like brainstorming with a friend over coffee. A good response to the above suggestions could be:

ChatGPT returns another list and includes more details about how it should be presented to the user:

At this point, there’s enough to start working on the first screen of the app. If you need more guidance, you can continue to ask for help. For example, if you’re unsure about the layout, you can ask the AI for guidance on elements like color schemes, UI elements and fonts.

You can, of course, try other prompts or ask for the responses in a different format. Sometimes, I’ll ask it to break its suggestions into tasks with acceptance criteria. I can then copy the results into project management software.

AI Programming Assistance

AI-assisted programming is a booming industry, with tools like GitHub Copilot and Amazon’s Code Whisperer gaining popularity. While some concerns about AI replacing programmers exist, rest assured that it won’t happen anytime soon (the reasons for which deserve a separate article). However, leveraging AI for code writing can be a game-changer in your programming journey.

You might be tempted to ask ChatGPT to build an entire screen or app for you. I’d advise against that. Here are a few reasons from ChatGPT itself:

1. Lack of Precision and Focus: AI models like ChatGPT are powerful, but their outputs may lack precision when dealing with extensive codebases. By asking AI to write code function by function, you maintain a sharper focus on individual components, reducing the risk of errors and ensuring better quality.
2. Easier Debugging and Testing: Smaller code snippets are easier to debug and test. When AI generates more comprehensive sections of code, it becomes challenging to isolate potential issues or errors, leading to lengthier debugging sessions.
3. Smoother Code Integration: Breaking down code into smaller pieces allows you to integrate it with existing codebases more smoothly. By gradually adding AI-generated functions, you can assess their compatibility and ensure they fit seamlessly into the overall structure.
4. Human-AI Collaboration: AI is a valuable assistant, but collaboration with human programmers remains crucial. Requesting code in smaller segments encourages a more cooperative and iterative approach, where human programmers review, refine and modify the AI-generated code as needed.

Of course, you can do whatever you like, but the quality and longevity of your code may suffer.

Code Generation

Astrology apps need to be able to convert a date of birth to a star sign. This is a perfect example of the kind of neat little functions we can ask ChatGPT to create for us.

Here’s the prompt I used:

And the response?

enum ZodiacSign: String {
  case aries = "Aries"
  case taurus = "Taurus"
  case gemini = "Gemini"
  case cancer = "Cancer"
  case leo = "Leo"
  case virgo = "Virgo"
  case libra = "Libra"
  case scorpio = "Scorpio"
  case sagittarius = "Sagittarius"
  case capricorn = "Capricorn"
  case aquarius = "Aquarius"
  case pisces = "Pisces"
}

func getZodiacSign(from date: Date) -> ZodiacSign {
  let calendar = Calendar.current
  let month = calendar.component(.month, from: date)
  let day = calendar.component(.day, from: date)
  
  switch month {
  case 1: // January
    return (day >= 20) ? .aquarius : .capricorn
  case 2: // February
    return (day >= 19) ? .pisces : .aquarius
  case 3: // March
    return (day >= 21) ? .aries : .pisces
  case 4: // April
    return (day >= 20) ? .taurus : .aries
  case 5: // May
    return (day >= 21) ? .gemini : .taurus
  case 6: // June
    return (day >= 21) ? .cancer : .gemini
  case 7: // July
    return (day >= 23) ? .leo : .cancer
  case 8: // August
    return (day >= 23) ? .virgo : .leo
  case 9: // September
    return (day >= 23) ? .libra : .virgo
  case 10: // October
    return (day >= 23) ? .scorpio : .libra
  case 11: // November
    return (day >= 22) ? .sagittarius : .scorpio
  case 12: // December
    return (day >= 22) ? .capricorn : .sagittarius
  default:
    // Invalid date, return a default sign (e.g., Aries)
    return .aries
  }
}

The code compiles and runs perfectly fine in Swift Playgrounds with no errors! Even better, ChatGPT created an enum for the zodiacs. This gives you options to add more functionality in the future, if you want.

However, can you see how there might be issues with dropping this into your project without reviewing it? What if the dates are wrong? Could there be a typo in the names? Is it slow?

It’s important that you review this code and make corrections where necessary, just as you would when bringing in code from other sources.

Thankfully, you can easily test this function. For this example, verification would only be a matter of researching the true date ranges and writing unit tests to cover a few birth dates.