DEV Community: Tosh

6 ChatGPT Prompts That Actually Help You Get Hired

Tosh — Sun, 19 Apr 2026 13:07:59 +0000

6 ChatGPT Prompts That Actually Help You Get Hired

Job searching without AI in 2026 is like doing market research without the internet. You can do it, but you're working twice as hard for half the information.

The problem is most people use ChatGPT wrong in job searches. "Write me a cover letter" produces the same generic output that hiring managers see 200 times a week. These prompts actually work.

Resume that matches the job description

Copy-paste the job description. Then:

"Here is my resume: [paste resume]. Here is the job description: "[paste JD]. Identify the top 5 skills and keywords the employer is prioritizing. Then rewrite my resume bullet points so they emphasize those skills, using language from the job description where it fits naturally. Don't invent experience I don't have — just surface what's relevant.\""

ATS systems and recruiters both scan for keyword alignment. This does in 2 minutes what a resume coach charges $300 for.

Cover letter that doesn't sound like ChatGPT

The standard "write me a cover letter" prompt is killing people's applications. Instead:

"I'm applying to [role] at [company]. Here's what I know about them: [3-4 specific things about the company, their product, recent news]. Here's my relevant background: [2-3 sentences]. Write a cover letter that opens with something specific about why I want this particular company — not the industry, not the role type, but this company. Keep it under 250 words. Sound like a person."

Specificity is the only thing that gets cover letters read.

Interview prep: the questions they actually ask

Not generic. Position-specific:

"I have an interview for [role] at [company]. Based on common interview patterns for this type of role, give me the 10 questions I'm most likely to face. For each one, give me a follow-up question the interviewer might ask if my first answer is too vague. Then help me think through what they're really trying to assess with each question."

The follow-up questions are what most people aren't prepared for.

STAR story builder

Behavioral interviews require specific stories and most people blank:

"I'm going to describe a work situation: [describe project, challenge, or accomplishment]. Help me structure this as a STAR answer (Situation, Task, Action, Result) that fits in 90 seconds when spoken. Make the Result section quantified if there's any way to do that given what I've told you. Flag if the story has any weak spots."

Weak spots: vague actions ("I helped with"), missing results, or stories where you weren't the main actor.

Salary negotiation

This is where most people leave money on the table:

"I've received an offer of [amount] for [role] at [company type / location]. Based on this role's typical market range, where does this offer sit? Give me the exact words to say when I respond — something that pushes for more without being aggressive. I want to stay warm but make clear I expect more. I'm willing to accept [your actual floor] but want to aim for [your target]."

The script matters. "I was hoping for more" is not a negotiation. "Based on the market rate and my experience with X and Y, I was expecting something closer to Z" is.

Rejection reframe

You got rejected. Before you spiral:

"I applied for [role] at [company] and was rejected at [stage: resume screen / phone screen / final round]. Based on typical rejection patterns at this stage, what are the most likely reasons? What's one thing I can specifically improve before my next application, and what's one signal I should look for in my next opportunity to better qualify myself before applying?"

Two rejections with good analysis are worth more than ten applications sent blind.

Get the full toolkit

500+ job search, negotiation, and career prompts organized by stage: https://toshleonard.gumroad.com/l/rzenot

The difference between a good job search and a great one is usually 3-4 right moves. This helps you find them.

ChatGPT Prompts for Graphic Designers: Create Faster, Think Bigger

Tosh — Sun, 19 Apr 2026 13:07:57 +0000

ChatGPT Prompts for Graphic Designers: Create Faster, Think Bigger

Designers who figured out how to use ChatGPT right aren't using it to make art. They're using it to get unstuck, think through client briefs faster, and kill the parts of the job that were never about design in the first place.

Here are the prompts that actually move the needle.

Before you touch the software

The worst time to start designing is when you don't know what you're trying to say. This prompt fixes that:

"I'm designing for [project: brand identity / landing page / poster / etc.]. The client is [brief description]. Help me identify the core visual problem this design needs to solve, in one sentence. Then give me 3 completely different conceptual directions — not aesthetic styles, but different ideas about what this design is communicating."

The output won't be perfect, but it forces you to think in concepts before you think in colors.

Client brief decoder

Clients say things like "make it pop" and "something modern but also classic." You can spend 30 minutes decoding that, or:

"Here's what my client said about their project: [paste brief or notes]. Translate this into specific design decisions — color palette direction, typography mood, imagery style, and layout approach. Then flag any contradictions in what they're asking for that I should clarify before starting."

This saves at least one revision cycle. Sometimes two.

Color palette exploration

Not to generate the palette — to stress-test it:

"I'm considering using this color palette for [project type]: [describe colors or hex codes]. What psychological associations do these colors carry? What industries use similar palettes, and what might that association trigger in viewers? What's the risk of this choice?"

Color theory you can read in a book. Context-specific psychology takes longer to develop on your own.

Typography pairing

"I've chosen [font name] as my primary typeface for a [project type] targeting [audience]. Suggest 3 pairing options for a secondary typeface, with reasoning for each. Explain the tension or harmony each pairing creates — I want options that feel intentional, not safe."

The "explain the tension" part is what makes this useful. Generic suggestions omit that.

Presenting work to clients

The design is done. Now you have to sell it without sounding like you're selling it:

"I'm presenting a [logo / brand identity / web design] to a client tomorrow. The main design choice they might question is [describe the bolder decision you made]. Help me write a 2-sentence rationale for this choice that's grounded in their business goals, not in design theory. They're not designers — they care about [what the client cares about]."

Clients don't reject designs. They reject designs they don't understand.

Scope creep email

You've been asked to add something that wasn't in scope. Again:

"I need to respond to a client who's asked for [describe the new request] which wasn't part of our original agreement. Write a professional email that acknowledges the request, explains it falls outside the scope of the current project, offers to handle it as a separate project with an appropriate timeline, and keeps the relationship warm. Tone: direct but friendly."

Copy it, edit three words, send it. Not worth stressing over.

Design feedback interpreter

You got feedback that you don't agree with. Before reacting:

"My client gave me this feedback on my design: [paste feedback]. Help me identify the underlying concern they're describing, separate from the specific change they're requesting. What might they actually be worried about — and is there a design solution that addresses the real concern without abandoning my original direction?"

Half of client feedback is a symptom of a different problem. This helps find the actual problem.

The one Gumroad plug

If you want more prompts organized by project type — branding, web, print, presentations — I packaged 500+ in a searchable format: https://toshleonard.gumroad.com/l/rzenot

Design faster. Think clearer. Stop writing emails from scratch.

ChatGPT for DevOps: Prompts That Speed Up Infrastructure Work

Tosh — Sun, 19 Apr 2026 10:29:38 +0000

ChatGPT for DevOps: Prompts That Speed Up Infrastructure Work

DevOps work has a particular texture that's different from application development. You're often reading something unfamiliar — a Kubernetes YAML someone else wrote, a Dockerfile from three years ago, a Bash script that's grown beyond anyone's ability to reason about — and you need to understand it quickly, modify it safely, or diagnose what went wrong.

ChatGPT is well-suited for this. Infrastructure configurations are highly structured, the problem domain is well-documented in its training data, and the tasks are often translational: "plain English to config" or "config to plain English." Here's how I've integrated it into my DevOps workflow.

Dockerfile Review and Optimization

Dockerfiles accumulate bad patterns over time. Layers that bust cache unnecessarily. Running as root. Installing tools that were needed for a build step but end up in the final image. Most teams have at least one Dockerfile nobody wants to touch.

Prompt: "Review this Dockerfile for a Node.js application. Identify any security issues, layer caching problems, image size inefficiencies, and best practice violations. For each issue, explain the problem and show the specific fix. Also tell me if there's anything that would cause this to behave differently between development and production environments. Here's the Dockerfile: [paste Dockerfile]"

The "explain the problem" instruction is important if you want to actually learn from the review rather than just apply the fix. I've caught real security issues with this — exposed secrets in ENV instructions, base images that haven't been updated in two years, unnecessary packages that expand the attack surface.

Kubernetes YAML From Plain English

Writing Kubernetes YAML from scratch is where I spend more time than I'd like to admit reading the docs. This prompt lets me describe what I want and get a starting point.

Prompt: "Generate Kubernetes YAML for a Node.js API service with the following requirements: 3 replicas, resource limits of 512Mi memory and 500m CPU per pod, environment variables loaded from a Secret named 'api-secrets', a readiness probe that checks /health every 10 seconds, and a horizontal pod autoscaler that scales between 3 and 10 replicas when CPU hits 70%. Include comments in the YAML explaining each non-obvious configuration choice. Target Kubernetes 1.28."

Always specify the Kubernetes version. Config that works on 1.24 can be deprecated by 1.28, and ChatGPT won't warn you unless you anchor it to a specific version. The comments instruction is also worth keeping — they help you understand what to change when requirements evolve.

CI/CD Pipeline Explanation

GitHub Actions workflows, especially ones you've inherited, can be dense. This prompt is my first move when I need to understand a pipeline quickly.

Prompt: "Explain what this GitHub Actions workflow does, step by step. For each job and each step, describe what it's doing and why it would be there. Note any potential issues: steps that could fail silently, missing error handling, security concerns with how secrets or permissions are handled, or anything that looks like a workaround for a deeper problem. Here's the workflow YAML: [paste workflow]"

The "workaround" instruction is underrated. Sometimes you look at a CI config and there's something that seems weird — an extra checkout step, a manual cache key that shouldn't need to be there — and it turns out to be papering over a real issue. ChatGPT will sometimes catch these.

Postmortem Writing From Log Dumps

Incident postmortems are important and almost always written badly, usually because they're written after an already exhausting incident by people who want to go home. Here's a prompt that gives you a structured draft to work from.

Prompt: "Here are the logs and timeline from a production incident where our API service started returning 500 errors for authenticated users. Write a postmortem in the format used by Google's SRE handbook: an incident summary, the timeline of detection and response, the root cause analysis, the contributing factors, and the action items with owners and due dates. Leave the owners and due dates as placeholders. Stick to facts — don't assign blame. Logs and timeline: [paste raw material]"

"Don't assign blame" is not just a nicety — it's a quality instruction. Blame-focused postmortems produce worse root cause analysis because they stop at the human action instead of the system condition that made that action possible.

Infrastructure Security Audit

This prompt is not a replacement for a real security audit, but it's a fast way to catch low-hanging misconfigurations before they become incidents.

Prompt: "Review these Terraform files for security misconfigurations. Focus on: publicly exposed resources that shouldn't be, overly permissive IAM policies, missing encryption at rest or in transit, security group rules that are too broad, and any credentials or sensitive values that appear to be hardcoded. For each issue, rate the severity as high/medium/low and explain the potential impact. Terraform files: [paste files]"

I run this before every infrastructure PR review. It catches the kind of mistakes that are easy to make when you're moving fast — an S3 bucket left public, a security group rule that opens 0.0.0.0/0 on a port it shouldn't.

Converting Bash Scripts Into Readable Form

Legacy Bash scripts are their own genre of horror. Dense one-liners, no comments, variables named tmp2. This prompt is how I make them reviewable.

Prompt: "Refactor this Bash script to be readable and maintainable. Add comments explaining what each section does and why. Break long one-liners into multiple lines with intermediate variables that have meaningful names. Add error handling for the operations that could fail silently. Do not change the behavior — only improve readability and robustness. After the refactored script, give me a plain-English summary of what the entire script does, what it assumes about the environment, and what could go wrong at runtime. Here's the script: [paste script]"

The "do not change the behavior" instruction is critical. Without it, ChatGPT will sometimes decide it knows a better way to accomplish something and silently change logic. For Bash especially, that's dangerous.

Treating the Output as a Starting Point

The common theme across all of these is that ChatGPT gives you a first draft or a review, not a finished product. For infrastructure work, that's especially important to internalize — a misconfigured Kubernetes resource or a missed security issue can cause real problems.

The pattern that works: use ChatGPT to get to 80% quickly, then apply your own knowledge of your specific environment to close the gap. The 80% speedup is real and meaningful. The remaining 20% is still your job.

I've put together 200 prompts that cover the full DevOps and developer workflow — from infrastructure to debugging to code review to deployment automation.

Get 200 ChatGPT Prompts for Developers — $19 instant download

ChatGPT for Technical Writing: Prompts That Turn Your Brain Dump Into Documentation

Tosh — Sun, 19 Apr 2026 10:24:22 +0000

ChatGPT for Technical Writing: Prompts That Turn Your Brain Dump Into Documentation

I hate writing documentation. I don't think I'm unusual in this. Most developers I know will spend two hours refactoring a function to make it 5% cleaner, then spend zero minutes writing down why it works the way it does.

The result is that we leave behind codebases full of tribal knowledge that lives in Slack threads, one engineer's head, or nowhere at all. New people get up to speed slowly. Old people waste time re-explaining things they already explained six months ago.

ChatGPT doesn't fix the motivation problem, but it dramatically lowers the friction. The workflow I've settled into is: dump the raw material in, describe the audience, get a draft, edit the draft. That last step still requires a human — but starting from something is 10x faster than starting from nothing.

API Documentation From Rough Comments

This is the highest-ROI use I've found. Most of us write comments that make sense to us in the moment but are useless to anyone else (or to us, six months later). ChatGPT can turn those comments into structured API documentation.

Prompt: "Here are the inline comments for a REST API endpoint that handles user authentication. Convert these into proper API documentation in the style of Stripe's docs: a clear description of what the endpoint does, the request parameters with types and whether they're required, the response format with example payloads for success and each error case, and any important notes about rate limiting or authentication. Here are the comments: [paste comments]"

Specifying a documentation style you admire (Stripe, Twilio, and Tailwind all have excellent docs) gives the model a quality bar to aim for. Without it you get generic documentation that technically contains all the information but reads like it was written by a committee.

READMEs People Actually Read

The average README contains an installation section, a vague "usage" section with one example, and a license. Nobody reads it. Here's a prompt that produces something better.

Prompt: "Write a README for this open-source npm library. The target audience is a mid-level frontend developer who has never heard of this library and is evaluating whether to add it to their project. Lead with the single most important thing this library does. Then show a complete working code example — not a toy example, but something close to real usage. Then cover installation, configuration options, and common gotchas. Tone: direct, no marketing language. Here's what the library does and how it works: [paste description and key code]"

The instruction to lead with the most important thing is doing a lot of work here. Most README intros bury the value proposition in jargon. The "no marketing language" instruction prevents output that sounds like a press release.

Changelogs From Git Log Output

Writing changelogs is something almost every team does badly. Here's how to generate a useful one from raw git history.

Prompt: "Here's the git log output for our last sprint. Convert it into a changelog in Keep a Changelog format. Group changes into Added, Changed, Fixed, and Deprecated sections. Rewrite commit messages from internal shorthand into clear descriptions that a developer using this library would understand — focus on what changed and why it matters to them, not implementation details. Ignore commits that are just merges, version bumps, or CI changes. Git log: [paste output]"

You'll still need to review it — sometimes commits are ambiguous and the model will guess wrong — but even a 70% accurate first draft cuts changelog time significantly.

Architecture Decision Records From Discussion Notes

ADRs are one of the most valuable things a team can write and one of the least written. The barrier is usually that the decision already happened in a Slack thread or a meeting, and writing it up properly feels like archaeology.

Prompt: "Here are notes from a discussion where we decided to switch from a monolithic database to read replicas for our reporting queries. Convert these into a formal Architecture Decision Record. Include: the context and problem we were solving, the options we considered and their tradeoffs, the decision we made and the reasoning, the consequences (both positive and negative), and any open questions that remain. Keep it factual — don't editorialize. Notes: [paste discussion notes]"

The "don't editorialize" instruction matters. ADRs should record what was decided and why, not advocate for whether the decision was correct.

Onboarding Documentation for New Engineers

Writing onboarding docs is time-consuming because you have to hold the new-person perspective in your head while describing something you understand deeply. ChatGPT is surprisingly good at this because you can tell it explicitly who the reader is.

Prompt: "Write a technical onboarding guide for a new backend engineer joining a team that builds a Django REST API with PostgreSQL and Celery for async jobs. The engineer has 2-3 years of experience but has never worked with Celery or our specific deployment setup on AWS ECS. Cover: how to get the local dev environment running, how our branch and PR workflow works, how to run and write tests, how Celery fits into the architecture, and the three most common mistakes new engineers make in their first month. Write it like a friendly senior engineer, not a formal manual."

The "three most common mistakes" section is the most useful part and the hardest to get right — you'll need to fill in those specifics yourself, but the prompt gets you the structure.

Release Notes for Non-Technical Stakeholders

Developers write release notes for other developers. Product managers and executives read release notes too, and they need a different version.

Prompt: "Here are the technical release notes for version 2.4 of our SaaS platform. Rewrite them as release notes for non-technical stakeholders: product managers, customer success managers, and executives. Focus on what changed for users, not how it was implemented. Lead with the most impactful user-facing change. Use plain language — no technical jargon, no references to infrastructure or code. Keep it under 300 words. Technical notes: [paste notes]"

The word limit forces prioritization. Without it you get a faithful translation of every technical change, which defeats the purpose.

The Editing Step You Can't Skip

None of these prompts produce final output. They produce first drafts that are structurally correct but may have wrong details, outdated information, or a tone that doesn't match your team's voice. The point is to get to a reviewable draft in five minutes instead of thirty.

The discipline is treating the output like a draft from a contractor, not a finished document. Read it critically, fix the specifics, publish it.

Documentation, API writing, onboarding guides, changelogs — there are prompts for all of it and more in the developer pack I put together.

Get 200 ChatGPT Prompts for Developers — $19 instant download

ChatGPT for Testing: Prompts That Write Tests You'd Actually Write Yourself

Tosh — Sun, 19 Apr 2026 10:19:05 +0000

ChatGPT for Testing: Prompts That Write Tests You'd Actually Write Yourself

I've written a lot of tests I'm not proud of. Happy path only. One assertion per function. The kind of tests that pass CI but don't catch anything real. A few months ago I started using ChatGPT as a testing collaborator, not to write the tests for me blindly, but to surface the cases I was lazily skipping.

The results were better than I expected — not because ChatGPT is magic, but because having to describe your function to it forces you to think clearly about what it's supposed to do.

Here's how I actually use it.

Starting From a Function Signature

The fastest workflow I've found is pasting in a function signature plus a one-sentence description and asking for a full test suite. The key is being specific about what kind of tests you want.

Prompt: "Here's a Python function that validates user-submitted email addresses before account creation. It takes a string and returns a boolean. Write a pytest test suite for it. Cover the happy path, invalid formats, edge cases with special characters, empty strings, and anything else that could cause a false positive or false negative. Include comments explaining why each test matters."

What you get back is usually 80% there. Some tests will be trivially obvious, a few will be genuinely useful cases you hadn't thought of. The comments are what I find most valuable — they force the model to articulate the intent behind each test, which I can then verify or reject.

The Edge Case Interrogation

This one has saved me more than once. You paste in a function and ask ChatGPT to think like an attacker — or just a very careless user.

Prompt: "Here's a JavaScript function that processes a payment amount from user input and applies a discount code. What inputs would cause this function to behave unexpectedly, return wrong results, or throw an error? List them as specific test cases I should write, not as general categories."

The "specific test cases, not general categories" instruction is important. Without it you get back a list like "test with null values" — useless. With it, you get "test with amount = '10.00' as a string instead of a number" and "test with discount code that has trailing whitespace" — things you can actually write assertions for.

Integration Tests From User Stories

My team writes user stories in the format "users should be able to..." before we write code. These are actually great seeds for integration test scenarios.

Prompt: "Convert these user stories into integration test scenarios for a React/Node.js app using Jest and Supertest. For each scenario, describe the setup state, the action to test, and the expected outcome. Don't write the code yet — just give me the test plan in plain English so I can review it first. User stories: [paste stories]"

Separating the planning from the implementation is deliberate. I want to review the test logic before the code gets generated, because ChatGPT will confidently write tests for the wrong behavior if the user story is ambiguous.

Generating Realistic Mock Data

This is unglamorous but genuinely time-consuming. Generating realistic nested mock objects for TypeScript types, especially when they have optional fields and union types, is tedious.

Prompt: "Here's a TypeScript interface for an order object in our e-commerce system. Generate 5 mock objects that cover different realistic scenarios: a standard order, an order with multiple line items and a discount, an order with a partially fulfilled status, an order with a foreign shipping address, and a failed payment order. Make the data look real — realistic names, product names, prices, and timestamps."

The "make it look real" instruction matters. If you skip it, you get name: "Test User" and price: 99.99 everywhere, which makes test failures harder to read and debug.

Turning Requirements Into Test Cases

Product requirements are usually written for humans, not test suites. This prompt bridges that gap.

Prompt: "Here's a requirements document section describing how our file upload feature should work. Translate each requirement into a specific test case title and a one-sentence description of what it asserts. Format it as a numbered list. Flag any requirements that are ambiguous or untestable as written: [paste requirements]"

The "flag ambiguous requirements" instruction is the most useful part. It turns ChatGPT into a QA reviewer who reads the requirements critically, which usually surfaces gaps before any code is written.

Coverage Gap Analysis

This one I run periodically on existing code. Paste in a function and the tests you already have, then ask what's missing.

Prompt: "Here's a Go function that parses configuration files, and here are the existing tests for it. What scenarios are not covered by these tests? Specifically call out any error paths, boundary conditions, or interaction effects that could cause bugs in production but would pass the current test suite."

I've found actual bugs this way — cases where my tests were passing but the function had silent failure modes I hadn't considered.

What ChatGPT Can't Do for You

It won't know your domain. It doesn't know that in your system, a "pending" order means something different from a "processing" order, or that order ID 0 is reserved. You still have to review everything it generates. Think of it as a testing junior who is very fast and never gets bored, but needs clear instructions and your sign-off on the output.

The prompts above give you a starting template. The real skill is iterating on them until they match your codebase's patterns and vocabulary.

If you want a full set of tested prompts across more testing scenarios — property-based testing, snapshot testing, test refactoring, flaky test diagnosis — I've put together a 200-prompt pack that covers the full developer workflow.

Get 200 ChatGPT Prompts for Developers — $19 instant download

ChatGPT for Project Coordinators: Prompts That Keep Projects on Track

Tosh — Sun, 19 Apr 2026 10:07:14 +0000

ChatGPT for Project Coordinators: Prompts That Keep Projects on Track

I've been a project coordinator for eight years across construction, software development, and healthcare operations. The job title changes, but the core challenge is always the same: there is more information moving around than any one person can organize, and the cost of miscommunication is paid by everyone on the team except the person who miscommunicated. When I started using ChatGPT to handle the writing and formatting work that eats up my day, I stopped drowning in documentation and started actually coordinating.

Here's what I use on a regular basis.

Status Update Emails That People Actually Read

Status updates are one of the most common things a coordinator produces and one of the most commonly ignored. The reason they get ignored is that most of them are written to show work rather than communicate it — long paragraphs, passive voice, no clear signal about whether things are on track or not.

ChatGPT won't fix a bad status update if you give it vague input. But if you tell it what actually happened this week, it will turn it into something readable.

Prompt: "Write a weekly status update email for a software implementation project. This week: completed user acceptance testing for module 2 with no critical defects, delayed the go-live for module 3 by one week due to a dependency on the client's IT team completing their infrastructure upgrade, and kicked off training for the core users. Next week: finalize module 3 readiness checklist, confirm go-live date with stakeholders. Audience: project sponsor and department heads. Keep it under 200 words and lead with the most important information."

What I get back is something I can send with light editing. No status theater. No buried lede. The right people get the right information without having to read four paragraphs to find it.

Risk Log Entries from Rough Notes

Maintaining a risk log is one of those things that sounds simple and is actually tedious. You have to capture the risk clearly, assess probability and impact, and describe a mitigation plan — all in consistent language that holds up if someone audits the project later.

When something comes up in a meeting, I take rough notes and then use ChatGPT to turn them into a proper entry.

Prompt: "Here's a situation that came up in today's call: our third-party vendor for data migration said they're currently understaffed and may not be able to hit the June 14th cutover deadline. We don't have a backup vendor identified. Write a risk log entry with a risk description, probability rating (low/medium/high), impact rating, and a mitigation plan. Use a professional, neutral tone suitable for a formal risk register."

This takes 30 seconds instead of 15 minutes. The entries are consistent with each other, which matters when someone needs to review the full log at a glance.

Meeting Minutes That Extract What Matters

Meeting notes are only valuable if people read them. Nobody reads a transcript. What they need is a clear record of what was decided, what's being done, and by whom.

Prompt: "Here are my rough notes from a 60-minute project steering committee meeting. Extract and format: (1) key decisions made, (2) action items with owner and due date, (3) issues that were raised but not resolved, and (4) a one-paragraph summary of the meeting. Format it as meeting minutes suitable for distribution to all attendees."

I paste in my notes — which are usually messy, mid-sentence, and missing context — and the output is a clean, professional document. I review it for accuracy, make corrections, and send it within an hour of the meeting ending. Before, that process took me the rest of the afternoon.

Task Breakdown from Vague Project Scope

One of the most common problems coordinators face is receiving a project scope that's too high-level to actually work from. "Migrate the customer portal" is not a project plan. Getting from a vague scope to a real task list used to require hours of back-and-forth with stakeholders.

Prompt: "I've been handed the following project scope: 'Migrate our customer support portal to the new vendor platform by Q3.' Break this down into a phased task list with logical groupings (e.g., discovery, vendor onboarding, data migration, testing, training, go-live). For each phase, list 4-6 specific tasks. Identify any dependencies between phases. Assume a team of 4 people with no dedicated technical resources."

The output gives me a starting structure I can bring to the kickoff meeting and refine with the team. It's not the final plan — but it's a plan I can react to, which moves things forward faster than starting from a blank spreadsheet.

Escalation Emails That Are Firm Without Being Hostile

Escalation is one of the harder communication tasks in project coordination. You need to clearly communicate that something is blocking progress and that inaction has consequences — without burning the relationship or making the other person defensive.

Prompt: "Write an escalation email to a vendor project manager who has missed three consecutive weekly check-in meetings and has not responded to two follow-up emails over the past 10 days. Our project go-live depends on their deliverable being completed by May 1st. The email should be firm, document the pattern, state the consequence clearly, and request a response within 48 hours. Professional but direct."

This is one of those emails I would have spent 45 minutes writing and still felt uncertain about. ChatGPT gets me to a draft in under a minute, and the tone is calibrated correctly — assertive without being combative, documented without being passive-aggressive.

Stakeholder Communication for Different Audiences

The same project update means something different to an executive sponsor and to the technical team executing the work. Writing two separate updates manually doubles the effort. With ChatGPT, I write it once and ask for it to be reframed.

Prompt: "I have a project update to communicate: we've hit a critical path delay of 2 weeks due to an integration issue between our CRM and the new billing system. Write two versions of this update: (1) an executive summary for the C-suite that focuses on timeline impact, business risk, and what decision they need to make, and (2) a technical update for the engineering team that explains the nature of the integration issue and the immediate next steps they need to take."

Two clear, audience-appropriate updates from a single prompt. The executive version leads with the business impact. The technical version goes straight to the problem details. Neither audience has to wade through information that isn't relevant to them.

The time I've recovered from these tasks is time I'm putting back into the actual coordination work — managing dependencies, building relationships with stakeholders, and catching problems before they hit the risk log. That's where the job actually lives, and that's where I want to spend my time.

Get the ChatGPT Prompt Pack for Professionals — $27

ChatGPT for Recruiters: Prompts That Fill Roles Faster

Tosh — Sun, 19 Apr 2026 10:01:57 +0000

ChatGPT for Recruiters: Prompts That Fill Roles Faster

I've been in talent acquisition for eleven years. I've worked agency, in-house, and as an embedded contractor for high-growth startups. In that time I've written thousands of job descriptions, sent tens of thousands of outreach messages, and sat through more debrief calls than I can count. When I started using ChatGPT in my daily workflow, I wasn't looking for magic — I was looking for leverage. I found it.

Here's what I actually use, and why it works.

Job Descriptions That Attract the Right People

Most job descriptions are terrible. They're a copy-paste of the last description someone wrote three years ago, padded with buzzwords and a paragraph about the company's ping pong table. Candidates see through it immediately — especially the experienced ones you actually want.

The fix is specificity. ChatGPT can't make a generic brief compelling, but if you give it real detail, it produces job descriptions that read like they were written by someone who actually does the job.

Prompt: "Write a job description for a Senior Product Marketing Manager at a Series B cybersecurity company targeting mid-market IT buyers. The role focuses on competitive positioning and sales enablement — not brand or demand gen. Required: 5+ years in B2B tech, experience translating technical concepts for non-technical buyers, and demonstrated ability to work closely with sales. Avoid corporate filler language. Write in a direct, confident tone."

The output gives me something I can post the same day with minor edits. More importantly, it signals to the right candidates that we know what we're looking for.

Personalized LinkedIn Outreach to Passive Candidates

Generic InMail gets ignored. I've tracked my own response rates for years — personalized messages that reference something specific about a candidate's background outperform templates by a wide margin. The problem is that writing personalized messages at scale is time-consuming.

ChatGPT makes this tractable.

Prompt: "Write a short, personalized LinkedIn outreach message to a passive candidate. Their background: 7 years in enterprise sales at Salesforce, recently promoted to Regional Director, based in Austin. The role I'm recruiting for: VP of Sales at a 150-person SaaS company targeting SMBs. Focus on why this role is a logical next step for someone at their career stage. Keep it under 100 words. No corporate jargon."

I drop in the candidate's background and the role context each time. The message takes 20 seconds to generate and another 30 to review. I'm sending genuinely personalized outreach at a pace that would have been impossible manually.

Interview Questions for Specific Roles

Behavioral interview guides for generic roles are easy to find. What's harder is building a question set that's actually calibrated to the specific role, level, and context you're hiring for.

Prompt: "Generate a behavioral interview question set for a mid-level DevOps Engineer role at a company migrating from on-premise infrastructure to AWS. Include 4 behavioral questions focused on cross-functional collaboration and handling ambiguity, and 4 technical scenario questions relevant to CI/CD pipelines and infrastructure as code. For each question, include what a strong answer looks like."

That last instruction — what a strong answer looks like — is the part that saves the most time. I'm not just getting questions; I'm getting a scoring guide I can share with hiring managers who've never conducted a structured interview in their lives.

Rejection Emails That Don't Burn Bridges

Candidate experience matters. A recruiter's reputation follows them across companies and hiring cycles. A well-written rejection email takes two minutes to send and costs nothing. A sloppy one gets screenshotted and posted on LinkedIn.

Prompt: "Write a professional rejection email for a candidate who interviewed for a Head of Design role and made it to the final round but wasn't selected. We genuinely liked them — they were strong but not the right fit for this specific stage of the company. Keep it warm, specific enough to feel personal, and leave the door open for future opportunities. Avoid hollow phrases like 'we'll keep your resume on file.'"

Candidates have told me they appreciated these emails. That's rare. It's a small investment with a real return.

Offer Letter Language and Compensation Clarity

Explaining a compensation package — especially one with equity, variable pay, or unusual benefits — is something recruiters often stumble through. Candidates ask questions we're not always prepared to answer clearly in the moment.

Prompt: "Help me write the compensation summary section of an offer letter for a Director-level hire. Base: $195,000. Bonus: up to 20% tied to individual and company performance, paid annually. Equity: 0.15% options with a 4-year vest and 1-year cliff. PTO: unlimited. Write this in plain language that a candidate who has never received equity before can understand. Avoid legalese."

I use this to draft language I then send to legal for review. It's not a replacement for your employment attorney — it's a way to get a readable first draft without spending an hour on it.

Candidate Evaluation Summaries from Interview Notes

After a full interview loop, someone has to synthesize the feedback. That person is usually me. I'll have notes from four or five interviewers, some of which are thorough and some of which are three bullet points typed on a phone.

Prompt: "Here are notes from a four-person interview panel for a Senior Data Analyst role. Synthesize a candidate evaluation summary that covers: overall recommendation, assessment of technical skills, communication and collaboration signals, areas of concern, and a suggested next step. Write it in a format suitable for sharing with the hiring manager."

Then I paste in the raw notes. What comes back is a coherent, structured summary I can send the same day. It's not replacing my judgment — it's giving me a clean document to react to rather than a blank page to fill.

None of this replaces the relational work that makes recruiting effective. What it does is eliminate the low-value writing tasks that eat up hours every week, so I can spend that time on the work that actually moves candidates through the funnel.

Get the ChatGPT Prompt Pack for Professionals — $27

ChatGPT for UX Designers: Prompts That Speed Up Research and Wireframing

Tosh — Sun, 19 Apr 2026 09:56:40 +0000

ChatGPT for UX Designers: Prompts That Speed Up Research and Wireframing

I've been a UX designer for nine years. In that time I've done hundreds of user interviews, written thousands of survey questions, and spent more hours than I care to count staring at a blank Figma canvas trying to frame a design critique in a way that wouldn't derail a client call. Last year I started using ChatGPT seriously — not as a crutch, but as a thinking partner that handles the scaffolding so I can stay focused on the actual design decisions. The difference in my output has been significant.

Here's what's working.

User Research Interview Questions

Writing interview questions sounds simple until you actually sit down to do it. You need questions that are open-ended but not so broad they produce useless answers. You need to avoid leading language. You need enough questions to cover your research goals without making the session feel like an interrogation.

ChatGPT does this well when you give it context.

Prompt: "I'm conducting user interviews with emergency room nurses to understand how they manage patient handoffs at shift change. Generate 10 open-ended interview questions that explore their current process, pain points, and any workarounds they've developed. Avoid yes/no questions."

The output typically gives me a solid draft in under a minute. I usually revise two or three questions, but I'm not starting from zero. For a project that requires three or four distinct interview guides, that time savings adds up to hours.

Persona Synthesis from Research Notes

After interviews, I'm sitting on pages of rough notes — quotes, observations, patterns I flagged but haven't organized yet. Turning those notes into a coherent persona used to take me the better part of a day. Now I paste my notes directly into ChatGPT.

Prompt: "Here are lightly edited notes from 6 user interviews with mid-level marketing managers about their content approval workflows. Synthesize a primary persona that captures the dominant patterns — include their goals, frustrations, behaviors, and a representative quote. Format it as a persona card."

What comes back isn't final. But it gives me something concrete to react to, which is always faster than generating from scratch. I'll refine the language and push back on anything that feels generic, but the structure is there.

Usability Test Scripts

A good usability test script has a specific rhythm: warm-up questions, task scenarios written in plain language, probing follow-ups, and a debrief. Getting that balance right takes experience — and even then it's tedious to write.

Prompt: "Write a 45-minute usability test script for a mobile banking app. The session will cover three tasks: transferring money to a new recipient, disputing a charge, and setting up a savings goal. Include a warm-up section, task scenarios written in non-leading language, and post-task questions for each scenario."

I've used outputs like this as a starting point for client-facing scripts. The task language usually needs tightening, but the overall structure is solid and saves me 90 minutes of drafting.

Design Critique Framing

One of the most useful things I've found is using ChatGPT to pressure-test my own designs before presenting them. I'll describe a flow in detail and ask for potential issues.

Prompt: "I'm designing an onboarding flow for a B2B SaaS tool aimed at ops managers in logistics companies. The flow has 6 steps: account creation, company profile setup, team invitation, integration connection, a guided first task, and a dashboard tour. What are 3 potential usability issues with this flow, and what questions should I be asking before I move to hi-fi wireframes?"

This is particularly useful when I'm too close to my own work. The model will flag things I've rationalized away — step count, cognitive load, edge cases in the invitation step. It's a cheap second opinion.

Writing UX Case Studies

Portfolio case studies are painful to write. You've done the work. You know what happened. Translating that into a narrative that's clear to someone who wasn't in the room is hard, especially after a long project.

Prompt: "Help me write a UX case study for my portfolio. The project was a redesign of a freight carrier's internal dispatch tool. The problem: dispatchers were using three separate systems and a whiteboard. My process included stakeholder interviews, workflow mapping, two rounds of usability testing, and iterative prototyping. The outcome: task completion time dropped by 34%. Write a 400-word case study narrative in first person, focusing on the problem, process, and measurable outcome."

I treat the output as a first draft. The facts are mine; ChatGPT handles the sentence-level work of making it readable.

Accessibility Checklists for Specific Flows

Generic accessibility checklists are everywhere. What's harder to find is a checklist scoped to your specific flow and user context.

Prompt: "Generate an accessibility checklist for a multi-step form flow designed for older adults (65+) applying for benefits online. Include considerations for visual design, form labeling, error handling, keyboard navigation, and screen reader compatibility. Reference WCAG 2.1 AA standards where relevant."

This gives me something I can actually hand to a developer or use in a design review, rather than pointing at a wall of WCAG documentation and hoping for the best.

The pattern across all of these is the same: I give ChatGPT context, constraints, and a format. It handles the scaffolding. I do the actual design thinking. That division of labor has genuinely changed how I work.

Get the ChatGPT Prompt Pack for Professionals — $27

ChatGPT for Copywriters: Prompts That Break Writer's Block

Tosh — Sun, 19 Apr 2026 09:51:24 +0000

ChatGPT for Copywriters: Prompts That Break Writer's Block

I've been a copywriter for eight years. I've written for SaaS startups, direct-to-consumer brands, B2B tech companies, and a few clients I can't talk about under NDA. I've hit every flavor of writer's block there is — the blank-page freeze, the "this brief makes no sense" spiral, the "I've rewritten this headline forty times and they're all bad" loop.

I was skeptical of AI copy tools for a while, and honestly, my skepticism was partly right. ChatGPT doesn't write great copy by default. Generic prompts produce generic output, and generic output in copywriting is worse than nothing — it looks like every other brand, converts poorly, and wastes client budget.

But used correctly, it's a genuinely useful tool for a specific set of jobs. Not replacement. Acceleration. Here's how I actually use it.

Generating Headline Variations Fast

The best headline often comes from option 15 or 20, not option 3. The problem is that generating 20 real options — distinct angles, not variations on the same idea — takes mental energy that's hard to sustain. I'll sometimes hit a wall at option 7 and start producing weak variations instead of genuinely different approaches.

ChatGPT doesn't get tired.

Prompt: "Write 12 headline options for a project management tool aimed at agency teams. The core benefit is that it reduces the number of meetings by making async updates clear enough that check-ins become optional. Vary the angles: include some benefit-driven, some curiosity-driven, some challenge-the-assumption, and a couple that are deliberately provocative. Don't repeat angles."

I scan the output, pull out 3–4 that spark something, and riff from there. The AI's weaker options often trigger my better ones. That's useful even when the output itself isn't the final answer.

A/B Testing Copy Variants With Different Hooks

A/B testing is only valuable if the variants are testing meaningfully different hypotheses. Most copy A/B tests I've seen are testing minor word swaps — "Get started" vs. "Start free" — rather than genuinely different angles, hooks, or emotional appeals.

ChatGPT is fast at generating real variants when you give it clear constraints.

Prompt: "Write 3 versions of a landing page hero section for a fintech app that helps freelancers save for taxes automatically. Version A: leads with fear of a tax bill surprise. Version B: leads with the feeling of control and confidence. Version C: leads with social proof and a specific outcome ('freelancers using [app] set aside the right amount every time'). Each version should have a headline, one-sentence subhead, and a CTA button label."

These give you structurally distinct variants worth actually testing, not cosmetic ones.

Tone Adjustment Without Rewriting From Scratch

I spend a lot of time rewriting copy for tone. Sometimes a client has existing copy that's fine structurally but wrong tonally — too casual for their actual buyers, too jargony for a landing page, too timid for a direct response context.

Prompt: "Rewrite this copy for a skeptical enterprise IT buyer. The current version reads as enthusiastic and consumer-friendly. The new version should be direct, assume technical competence, address objections upfront, and avoid hype language. Here's the original: [paste copy]"

Prompt: "This email is written for a general audience. Rewrite it for a senior executive who has 30 seconds to read it. Lead with what's in it for them, cut anything that doesn't earn its place, and don't use passive voice."

This use case saves me the most time on client revisions. Instead of rewriting from scratch, I'm editing a competent first pass.

Brief Interpretation and Angle Discovery

Creative briefs range from excellent to baffling. When a brief is underspecified, I used to either make assumptions and hope, or go back to the client for a 45-minute call to extract what they actually wanted.

Now I put the brief into ChatGPT and ask it to help me find the angles.

Prompt: "Here's a creative brief. Based on what's here, what are 5 meaningfully different angles I should consider for this campaign? For each angle, describe the emotional hook, the implied buyer belief it's leveraging, and a one-sentence headline direction. Brief: [paste brief]"

This doesn't replace the strategy thinking — but it surfaces angles quickly, and sometimes it names something I was circling around without articulating.

Self-Editing Pass

The hardest part of editing your own copy is that you can't see what's actually there — you see what you meant to write. Getting a second set of eyes takes time you don't always have.

Prompt: "Read this copy and tell me what's weak about it. Be direct. I'm looking for: where the logic is soft, where I'm being vague when I should be specific, where I'm burying the most important thing, and any sentences that aren't pulling their weight. Here's the copy: [paste copy]"

I don't take every piece of feedback, but this consistently catches at least one or two things I'd missed. That's worth 60 seconds of prompting.

Voice Consistency Check

When I'm producing multiple pieces for a client — emails, ads, web pages, social — keeping a consistent voice across all of them is harder than it sounds, especially under deadline pressure. Small inconsistencies accumulate and the brand starts to feel unfocused.

Prompt: "Here are four pieces of copy written for the same brand. Identify any voice inconsistencies across them — differences in formality, sentence rhythm, vocabulary register, or emotional tone. Note which piece feels most 'on-voice' and what qualities define that voice. Pieces: [paste all four]"

This is a 5-minute quality check that used to require either a careful manual read or the client catching the problem on review.

What This Changes

The time savings on any individual prompt are modest — 10 minutes here, 20 minutes there. The real gain is cognitive. Blank-page anxiety is real, and it costs time that doesn't show up on any timesheet. Starting with something — even mediocre AI output — breaks the paralysis faster than staring at a cursor.

The copywriters who struggle with AI tools are using them like a replacement. The ones getting value are using them like a sparring partner: fast, tireless, and useful for generating raw material that their own judgment then shapes into something good.

Get the ChatGPT Prompt Pack for Professionals — $27

ChatGPT for Operations Managers: Prompts That Keep Everything Running

Tosh — Sun, 19 Apr 2026 09:46:07 +0000

ChatGPT for Operations Managers: Prompts That Keep Everything Running

I've been in operations for fourteen years, the last six as an ops manager for a mid-size distribution company. My job is basically to keep a lot of plates spinning simultaneously — vendors, process documentation, team communication, reporting, firefighting — while also trying to improve the systems that caused the fires in the first place.

The honest truth about operations management is that the actual thinking isn't the bottleneck. The bottleneck is documentation. Writing things down in a clear, usable format is what eats the calendar. SOPs that nobody reads because they're poorly written. Vendor emails that take 30 minutes to draft because the right tone is tricky. Meeting summaries that never get written at all because there's no time.

ChatGPT doesn't run my operations. But it handles the documentation layer in a way that's genuinely changed how I work.

Writing SOPs From Rough Notes

Standard operating procedures are only valuable if people can follow them. Most SOPs I've inherited — and honestly, a few I've written — are a mess. They're written in a hurry, skip obvious steps, or bury the important stuff in paragraphs nobody reads.

When I need to document a process, I now dump my rough notes or a verbal walkthrough into ChatGPT and let it structure the output.

Prompt: "Turn these rough notes into a step-by-step SOP for [process name]. Format it with a numbered list, include a purpose statement at the top, list any tools or resources required, and add a 'common mistakes' section at the end. Notes: [paste notes]"

What used to take 90 minutes now takes 25. And the output is cleaner — because the AI imposes structure I'd otherwise skip when writing in a rush.

Vendor Communication That Hits the Right Tone

Vendor emails are a specific skill. Too soft and you don't get action. Too aggressive and you damage a relationship you need. Getting the tone exactly right for a late delivery, a pricing dispute, or a post-incident debrief requires more deliberate writing than most people realize.

Prompt: "Write an email to a vendor whose shipment is 9 days late with no update. We have a contract with on-time delivery requirements. The tone should be firm and professional — not hostile, but clearly communicating that this is unacceptable and we need both a status update and a recovery plan within 24 hours."

Prompt: "Draft an email opening a price renegotiation conversation with a long-term supplier. We've been with them 4 years, volume has increased 30%, but their pricing hasn't moved. I want to signal we're serious without being threatening. Keep it under 200 words."

I still edit these — every vendor relationship is different — but the first draft is 80% there, and that's where most of the time goes.

Meeting Summaries With Action Items and Owners

Operations meetings generate decisions and tasks. Those decisions and tasks need to be written down, assigned, and tracked. In practice, the person running the meeting rarely has time to write a clean summary, so it either doesn't happen or it happens poorly.

Prompt: "Here are my notes from a 45-minute ops meeting. Produce a summary in three sections: key decisions, action items (each with owner and due date), and open questions requiring follow-up. Notes: [paste notes]"

I send these summaries within 20 minutes of every meeting now. Before, it was either 2 hours later or never. The accountability difference is noticeable.

KPI Reporting Narratives for Weekly Reviews

Every week I report on a set of operational KPIs. The numbers are in the spreadsheet. The narrative — what the numbers mean, why they moved, what we're doing about the gaps — is what takes time.

Prompt: "Write a weekly ops narrative for a leadership review. On-time delivery rate was 91.2%, down from 94.1% last week due to a carrier issue on the East Coast route that has since been resolved. Warehouse fill rate hit 98.4%, a new high. Labor hours per order increased 6% due to a new product line onboarding. Flag the delivery rate as a watch item and note the fill rate as a win."

This takes a task that used to take me 40 minutes and turns it into a 10-minute editing job.

Root Cause Analysis Write-Ups

When something breaks, I have to document what happened, why it happened, and what we're doing to prevent recurrence. The 5-Why format is the right structure for this — but writing it clearly, especially when you're also in the middle of fixing the problem, is hard.

Prompt: "Write a 5-Why root cause analysis for the following incident: [describe incident]. Format it as a structured document with: incident summary, timeline, 5-Why chain, root cause statement, and corrective actions. Keep the language factual and non-blame-focused."

Having a clean RCA document is also useful for vendor conversations, insurance documentation, and internal process reviews. The discipline of the format forces clearer thinking.

Drafting Process Change Announcements

When a process changes, the announcement matters almost as much as the change itself. Poorly communicated process changes cause confusion, resistance, and workarounds. People need to understand the why, not just the what.

Prompt: "Write an internal announcement for a process change. Starting next Monday, all purchase orders over $5,000 require secondary approval from the finance team before submission. The reason is improved budget visibility, not a performance issue. Tone should be matter-of-fact and positive. Include what's changing, when, what people need to do differently, and who to contact with questions."

Where the Time Actually Goes

Operations managers spend a disproportionate amount of time on documentation that nobody taught us to do efficiently. SOPs, incident reports, vendor correspondence, meeting summaries — this is the invisible work that holds operations together.

When that documentation layer gets faster, the whole job gets better. I'm not spending the last hour of my day writing summaries for meetings that happened at 9am. I'm using that hour on the problems that actually need my judgment.

The prompts above are the ones I return to week after week. The common thread: be specific about context, format, tone, and audience. The more you put in, the less editing you do on the way out.

Get the ChatGPT Prompt Pack for Professionals — $27

ChatGPT for Accountants: Prompts That Make Tax Season Less Painful

Tosh — Sun, 19 Apr 2026 09:40:50 +0000

ChatGPT for Accountants: Prompts That Make Tax Season Less Painful

I've been a CPA for eleven years. I've survived seventeen tax seasons, three software migrations, and more client emails starting with "quick question" than I can count. None of those "quick questions" were ever quick.

What I've found over the past couple of years is that ChatGPT doesn't replace the judgment that comes with experience — but it does eliminate a lot of the repetitive cognitive work that eats up my day. Writing the same explanation of depreciation for the fourteenth client this month. Drafting a polite-but-firm email about a missed document deadline. Turning messy meeting notes into a clean action item list.

That's where AI earns its keep. Here's how I actually use it.

Explaining Complex Tax Concepts Without Losing Clients

The hardest part of accounting isn't the math. It's translating what the tax code actually means into language that a small business owner can act on without their eyes glazing over.

I used to spend 20 minutes crafting these explanations from scratch every time. Now I don't.

Prompt: "Explain the concept of Section 179 depreciation to a small business owner who just asked why they can't deduct the full cost of a $15,000 piece of equipment this year. Use plain language, no jargon, and keep it under 150 words."

Prompt: "A client received a K-1 from a partnership for the first time and is confused about what it means for their personal taxes. Write a short, friendly explanation I can paste into an email. Assume they have no accounting background."

These save me 15–20 minutes per client communication, and the explanations are often clearer than what I'd draft in a rush.

Client Communication About Difficult Situations

Nobody likes being the bearer of bad news. When a client owes more than expected, or when their books have issues that need addressing, the email I send has to be firm, empathetic, and professional — all at once.

Prompt: "Draft a client email explaining that due to changes in their business income and insufficient withholding, they will owe approximately $8,400 at filing. The tone should be calm and solution-oriented. Include a sentence about scheduling a call to discuss estimated quarterly payments going forward."

ChatGPT gives me a solid first draft in seconds. I read it, adjust for what I know about the client's personality, and send it. What used to take 25 minutes takes 5.

Variance Analysis Summaries for Management Reports

I work with several small-to-mid-size businesses where I prepare monthly management reports. The analysis itself requires my judgment. But the narrative? That's where AI helps.

Prompt: "Write a variance analysis narrative for a management report. Revenue came in 12% below budget due to delayed project starts in Q3. Operating expenses were 4% over budget, primarily driven by an unplanned equipment repair in October. The tone should be professional and factual, suitable for a business owner reviewing a monthly P&L."

Instead of staring at a blank page for 10 minutes, I get a working draft and refine it. Across a portfolio of clients, this adds up to hours saved per month.

Turning Meeting Notes Into Structured Action Items

My client meeting notes are, frankly, a mess. They're a combination of bullet fragments, half-sentences, and things I scribbled while someone was talking. Getting those into a clean, organized summary used to be a task I'd put off until end of day.

Prompt: "Here are my raw notes from a client meeting. Organize them into: (1) decisions made, (2) action items with owner and due date where specified, and (3) open questions that need follow-up. Notes: [paste notes]"

This is one of the highest-leverage things I do with ChatGPT. Clean meeting summaries mean nothing falls through the cracks, and clients feel like they're working with someone organized.

Writing Engagement Letters and Scope-of-Work Documents

Engagement letters are important, but writing them is tedious. I have templates, but every engagement has nuances that require customization — and that customization used to mean a lot of manual editing.

Prompt: "Draft an engagement letter for a tax preparation engagement for a sole proprietor with a single-member LLC. Services include federal and state individual returns, Schedule C preparation, and one planning call. Payment terms are 50% upfront, 50% on delivery. Professional tone, standard limitation-of-liability language."

I still review everything carefully before it goes out. But the structure is there, the language is clean, and I'm not writing from a blank page.

Summarizing Regulatory Changes for Client Newsletters

Keeping clients informed about tax law changes is good service — but distilling a 60-page IRS notice into three readable paragraphs isn't something I have unlimited time for.

Prompt: "Summarize the key changes from the [specific IRS notice or legislation] that are relevant to small business owners. Write it for a client newsletter — accessible, under 200 words, no footnotes, with a note to consult their tax advisor for specifics."

This takes a task that used to take an hour of reading and writing and compresses it to 15 minutes of reading, prompting, and editing.

The Real Time Math

Across client communications, meeting summaries, engagement letters, variance narratives, and educational content, I've estimated I recover 5–8 hours per week during busy season. That's not a minor efficiency gain — that's the difference between leaving the office at 7pm versus 10pm in April.

The prompts matter. Vague prompts get generic output. Specific prompts — with context, constraints, and the intended audience — get output you can actually use. That's the skill, and it's learnable.

Get the ChatGPT Prompt Pack for Professionals — $27

ChatGPT for Debugging: How I Use It as a Rubber Duck That Talks Back

Tosh — Sun, 19 Apr 2026 09:38:57 +0000

ChatGPT for Debugging: How I Use It as a Rubber Duck That Talks Back

I've been writing code for about eleven years and I still get stuck on bugs. Not the "this took me five minutes" kind — the "I've been staring at this for four hours and I cannot see it anymore" kind.

The classic solution is rubber duck debugging. You explain the problem out loud to an inanimate object, and the act of explaining it forces you to organize your thinking, and somewhere in the middle of that explanation you realize what's wrong. It works surprisingly well.

ChatGPT is a rubber duck that pushes back. And the difference matters more than I expected.

Why Most Developers Use It Wrong

The most common debugging prompt I see developers use is something like: "I'm getting this error: [paste error message]. What's wrong?"

That prompt produces generic answers. Stack Overflow answers. "Check that your environment variables are set correctly" and "make sure your dependencies are installed." You've already done those things. The answer isn't useful.

The problem isn't ChatGPT. The problem is that you've given it almost no information. An error message is the last thing that happened — it's not the context you need to diagnose why it happened. Without context, ChatGPT gives you generic advice because generic advice is the only thing that fits.

The fix is giving it more. A lot more.

The Context Dump Pattern

This is the core technique. Before I paste anything into ChatGPT, I answer four questions:

What is this function/code supposed to do?
What inputs am I passing it?
What did I expect to happen?
What actually happened?
What have I already tried?

Then I write all of that in the prompt. This sounds like more work, but it usually takes two minutes, and it almost always produces a useful answer on the first try.

Prompt: "I'm debugging a Node.js function that processes webhook events from Stripe. The function receives a raw request body, validates the Stripe signature, then inserts an event record into Postgres. Input: POST request with a valid Stripe-Signature header and a JSON body. Expected: the signature validates and the record inserts. Actual: the signature validation always fails, throwing 'No signatures found matching the expected signature for payload.' I've already checked: the webhook secret is correct (copy-pasted from dashboard), the raw body is being preserved (using express.raw() middleware), and the error happens on every request, not intermittently. Here's the relevant code: [paste code]"

That prompt gets a diagnosis, not a suggestion to check the docs. In this specific case, ChatGPT caught that I was parsing the body as JSON before the signature check, which was mutating the raw bytes the HMAC validation needs. Two minutes to write the prompt, thirty seconds to read the answer.

Log Analysis: Pattern Recognition at Scale

Reading logs is tedious, and the signal you need is usually buried in volume. Fifty lines of logs contains maybe three relevant ones. ChatGPT is fast at this kind of pattern matching.

Prompt: "Here are 60 lines of application logs from a crash that happened in production. The service is a Python FastAPI app that processes image uploads. I need to understand: what sequence of events led to the crash, which log line is the actual root cause vs. downstream effects, and whether there are any patterns suggesting this could recur. [paste logs]"

The key framing here is "root cause vs. downstream effects." Most error chains have one source and three symptoms. Reviewers (human or AI) will fixate on the last visible error, which is often a symptom. Asking explicitly for root cause forces a different kind of analysis.

Intermittent Failures: Systematic Hypothesis Generation

Intermittent failures are the worst bugs to debug because you can't reproduce them reliably. You can't print-debug your way through them. What you need is a list of plausible hypotheses you can systematically rule out.

Prompt: "I have an intermittent bug in a TypeScript service that calls an external API. The failure rate is roughly 2%, always returning a timeout, but only during business hours and only under load. It does not fail in staging. I've already ruled out: rate limiting (we're well under the limit), DNS resolution issues (no errors in that layer), and the external API's status page (clean). Generate a prioritized list of hypotheses for what could cause this pattern — timeout, load-dependent, time-of-day, works in staging — and suggest how to test or instrument each one."

"Prioritized list of hypotheses" is the key phrase. You want something testable, not a general description of timeout debugging.

Stack Traces for Unfamiliar Libraries

Nothing makes you feel like a junior developer faster than hitting a cryptic stack trace in a library you've never debugged before. The error is somewhere in 12 layers of framework internals and you don't know which layer is actually wrong.

Prompt: "Here's a stack trace from a Python Django application. I'm relatively unfamiliar with Django's request lifecycle. Walk me through what each layer of this stack trace is doing, identify where in the stack the actual error likely originated vs. where it surfaced, and explain what I should look at first in my own code. Stack trace: [paste trace]"

This prompt has saved me enormous amounts of time when I'm working in a framework I don't know well. It's also genuinely educational — reading the explanation a few times and you start to internalize the framework's internals.

The "Explain It Like I'm New to This" Prompt

Sometimes the problem isn't that you can't find the bug — it's that you don't understand what the error actually means. Especially with distributed systems errors, cryptic database messages, or framework-specific exceptions.

Prompt: "Explain this error message like I'm a junior developer who's never worked with this framework before: [paste error]. Then tell me: what state does this error indicate the system is in, what likely caused it, and what's the simplest thing to check first."

The "what state does this error indicate" framing is powerful. Errors are symptoms of state. Understanding the state is more useful than Googling the error string.

The Underlying Technique

Every prompt above follows the same logic: give ChatGPT enough context to reason about your specific problem, not the general class of problem. The more specific the input, the more specific and useful the output.

Rubber duck debugging works because explaining your problem forces you to organize your thinking. ChatGPT gives you the same benefit and then responds with hypotheses you hadn't considered. That's the combination that actually shortens debugging sessions.

If you want a complete set of prompts structured this way — covering code review, system design, documentation, and more — I've compiled 200 of them tuned for daily developer work.

Get 200 ChatGPT Prompts for Developers — $19 instant download