It’s English.

End of post. Goodbye!

Wait, let me explain. A few years ago, a topic like this would have been a debate comparing the growing list of programing languages available to developers and to be very honest, this is still very valid for developers. Writing code for important projects is not going anywhere soon.

For non developers, or as we call ourselves – non tech in tech however, we’re entering a time when the real power isn’t in learning to write code to solve some of our problems but in giving clear instructions to the AI models that do the heavy lifting. The technical tools available today aren’t just for developers. They’re for anyone who knows how to think and give clear actionable instructions.

Remember when everyone used to proudly put “Proficient in Microsoft Office Tools” on their CVs? I expect to start seeing things like “Skilled in AI Prompting” in the next couple of years because if you know how to prompt well, you can build, automate, design, generate – you name it. All with just your words.

Let me make this real for you. Say you’re a programmer who wants to write a Python script to fetch weather data using an API.

You prompt the AI with:

“Write a Python script to get weather data.”

Here’s what you get, except the AI model intuitively adds more context itself:

import requests

response = requests.get("https://api.weatherapi.com/data")
print(response.json())

It’s… something. But vague. Broken. No context, no structure, and won’t even run without fixing a bunch of things.

Now let’s revise the prompt:

“Write a Python script that uses the OpenWeatherMap API to fetch the current temperature for a given city. The city name should be taken from user input, and the script should handle invalid responses gracefully. Assume the API key is stored in a variable called API_KEY.”

The AI now gives you this:

import requests

API_KEY = "your_api_key_here"  # Replace with your actual API key

def get_temperature(city_name):
    base_url = "http://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city_name,
        "appid": API_KEY,
        "units": "metric"  # Use "imperial" for Fahrenheit
    }

    try:
        response = requests.get(base_url, params=params)
        response.raise_for_status()  # Raise exception for HTTP errors
        data = response.json()

        temperature = data["main"]["temp"]
        print(f"The current temperature in {city_name} is {temperature}°C.")

    except requests.exceptions.HTTPError as http_err:
        if response.status_code == 404:
            print(f"City '{city_name}' not found. Please check the name and try again.")
        else:
            print(f"HTTP error occurred: {http_err}")
    except requests.exceptions.RequestException as err:
        print(f"Network error: {err}")
    except KeyError:
        print("Unexpected response format.")
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    city = input("Enter the name of the city: ").strip()
    if city:
        get_temperature(city)
    else:
        print("City name cannot be empty.")

That’s a real, runnable script with user input, error handling, and clean logic.

Another example. This time, you’re a QA tester.

Prompt 1: “Check if the feature works.”

Result:
The AI runs a generic test case, returns a “looks good,” but misses edge cases, fails to log environment details, and doesn’t capture user flow interruptions.

Prompt 2: “Simulate a user logging in via mobile Safari on a slow 3G connection, then attempt to complete a purchase using a 20% discount code that expires in under 5 minutes. Log any UI lags, API failures, and discrepancies in total pricing.”

Result:
The AI runs a tailored end-to-end test suite, catches a bug in how the promo code expires, flags a miscalculation in the tax component, and saves a detailed report with timestamps and browser specs.

Same AI model. Same goal. Clear difference based on how the request was phrased.

So dear technical product manager, QA tester, developer trying to ship faster, or any other non tech in tech, the skill that matters now is the ability to prompt with clarity and purpose.

Also, if you’ve ever said “I’m not technical,” this is your time. You don’t need to write loops or debug memory errors. You just need to know how to think clearly, ask precisely, and communicate effectively.

In 2025 and beyond, prompting is programming.

So if someone asks what programming language you speak?

Just smile and say:
“English. Fluently.”