Problem Solving with AI: A Tale of Two Problems
Here are two very different tasks staring at you from your monitor on a Tuesday morning. Task A is a communication headache: a Product Manager just sent you a rambling, three-page Slack message full of half-baked feature ideas, and you need to turn it into a precise, actionable Jira ticket. Task B is a logistical nightmare: you have a team of 15 engineers, all with different PTO schedules, deployment constraints, and timezone overlaps, and you need to build a flawless three-month on-call rotation schedule.
On the surface, these look like entirely different jobs. One requires the finesse of a technical writer; the other requires the analytical brain of an operations manager. If you were delegating these tasks, you would give them to two different people. But when you are sitting in front of an Artificial Intelligence, you are going to solve both of these problems using the exact same method.
The secret to mastering AI is realizing that the machine doesn’t care if it’s parsing syntax or calculating arrays. It is simply a reasoning engine waiting for instructions. Engineers get frustrated with AI because they treat it like a search engine or try to memorize an endless list of specific “prompts.” But if you learn the underlying pattern, you never need to memorize a prompt again. Every problem is solved by providing the machine with three specific variables.
The universal formula is this: Methodology + Context + Format.
First, you must give it a Methodology. Instead of telling the AI to “act like an expert” (which just makes it output generic corporate jargon), tell it what professional constraints to apply. Second, you must give it the Context. The AI has all the general documentation in the world, but it has zero knowledge about your proprietary stack—you must supply the hard facts, the logs, or the code. Finally, you give it the Format. Tell the machine exactly what the final output should look like (JSON, Markdown, YAML) so you don’t have to reformat it.
Applying the Pattern
Let’s apply this formula to our simple problem first: the PM’s rambling Slack message. Instead of saying, “Make this shorter,” you use the pattern.
Methodology: “Apply Agile project management principles to parse this text. Remove all filler, extract the core technical requirements, and define the acceptance criteria.”
Context: “The target audience is the backend engineering team. The key constraints that must remain are the target latency (<50ms), the database type (PostgreSQL), and the deadline (Q3). Here is the original message: [Paste Message].”
Format: “Output this as a standard Jira ticket format, using Markdown, with sections for Epic, User Story, and Acceptance Criteria.”
Instantly, the wall of rambling text is transformed into a deployable ticket.
Now, let’s take that exact same formula and apply it to our large problem: the three-month on-call rotation. Instead of staring at a blank spreadsheet for four hours, you run the pattern.
Methodology: “Apply logistical operations constraints to build an on-call schedule. Ensure no engineer is scheduled for weekend duty twice in a month, and respect all listed PTO blackouts.”
Context: “I need a 12-week PagerDuty rotation starting this week. I need 1 Primary and 1 Secondary per week. Here is the list of 15 engineers, their timezones, and their approved PTO dates: [Paste messy list of notes].”
Format: “Output this as a clean CSV table with columns for Start_Date, End_Date, Primary_OnCall, and Secondary_OnCall, so that I can import it directly.”
In seconds, the machine calculates the variables, respects the constraints, and hands you a completed schedule.
Let’s go deeper.
You are wrestling with a system error. Simple or complex—it makes no difference. Watch.
When a localized bug arises, the natural instinct is to Google the error code, click through endless StackOverflow threads, and hope someone else had the exact same environment. But debugging is just another problem to run through the machine. Let’s apply the formula to a simple backend issue. Your application is throwing an error, and you are staring at a massive wall of server logs.
Methodology: “Apply standard systems engineering principles to parse server logs and diagnose a runtime failure.”
Context: “I am running a Node.js application. It is crashing on startup. Here are the last 150 lines of the console log: [Paste logs].”
Format: “Do not explain the entire log. Output a simple checklist telling me exactly which line caused the fatal error, what the error means, and the specific file I need to open to fix it.”
Instead of generic documentation, the AI acts like a senior engineer standing next to your desk, pointing exactly to the stack trace.
Visual Context
But what if the problem is an ugly, hairy beast? Imagine you are trying to configure complex routing rules in a new cloud environment (e.g., AWS Route 53 or Azure Front Door), and the documentation is deprecated. You log into the console, and there are hundreds of menus, toggles, and warnings. You don’t even know what terminology to use to explain where you are, and you are terrified of misconfiguring a rule and taking down production.
Here is where you use your imagination. Context doesn’t have to be text. Context can be visual. You take a screenshot of the confusing AWS console, upload it to the AI, and run the pattern:
Methodology: “Apply enterprise DevOps guidance to safely configure DNS routing settings without causing downtime.”
Context: “I am trying to verify a new subdomain routing rule for our production environment. I am lost in this AWS console. I am attaching a screenshot of exactly what is on my screen right now.”
Format: “Act as an over-the-shoulder guide. Output instructions for me to follow one click at a time. Only tell me what to click based entirely on the buttons visible in this screenshot. Ask me for a new screenshot after I click.”
Look at what just happened. You didn’t need to know the technical terms for the menus you were looking at. You didn’t have to write out a detailed description of the console. By taking a screenshot, you instantly imported your exact reality into the machine’s context window.
Whether you are parsing a feature request, calculating a three-month deployment schedule, or navigating a labyrinth of cloud architecture settings, the AI is ready to execute. The limit of the AI is not its intelligence; it is your ability to describe your reality to it. The more precise you are in supplying the Context, the Methodology, and the Format, the more powerful the machine becomes.
You don’t need a thousand different prompts.
You just need the pattern.