My GitHub Copilot Journey - Part 3: Beyond Code

I hired a coding assistant. Then I realized it's not a coding assistant. It's a thinking assistant that happens to be really good at code.

In Part 1 I built the reflex. In Part 2 I learned to go deep. Part 3 is about going wide — and to me, this is where things got really interesting.

The category explosion

Looking back at my usage patterns, something happened around week 4. My sessions, which had been almost entirely about code, started fragmenting into wildly different categories (I honestly didn't plan this, it just sort of happened):

• Configuration analysis and auditing
• Professional email drafting
• Market and competitive research
• Strategic analysis
• Educational content creation
• Data analysis and visualization

Not gradually. Suddenly. Once I trusted the tool for code, I started testing it on everything. And it kept working. I have been trying to find the limits of what it can handle, and to be honest — it's broader than I expected 😊.

The pattern that unlocks domain expansion

Here's the specific prompt pattern that works across domains. It's not complicated, but it makes a dramatic difference (I won't go into too much detail on prompt engineering theory here — just the practical bits):

Bad prompt (works, but barely):

"Analyze this website's SEO."

Good prompt (produces actionable output):

"I have a website at [URL]. The target audience is [X]. The goal is [Y]. Can you do a comprehensive audit covering technical SEO, content quality, meta tags, mobile readiness, and page speed indicators? Prioritize findings by impact."

The difference is context. The more you tell the AI about the situation, the goal, the audience, and the constraints, the better the output. This is true for code, and it's equally true for business tasks, research, communication — everything.

Pro Tip: Write your prompts as if you're briefing a new colleague on their first day. Include the "why" and the "who" — not just the "what." You'll be surprised how much better the output becomes.

This is also why domain expansion happens naturally: once you learn to write detailed prompts for code, you already know how to write them for anything else. The skill transfers.

Concrete examples of non-code usage

Let me be specific about what this looks like in practice (I realize these examples are from my own workflow, so your mileage may vary — but the patterns should be transferable):

Strategic analysis

I needed to evaluate a business opportunity. Instead of spending half a day researching, I described the situation:

"I'm considering [opportunity]. Here's what I know: [context]. I need to understand the competitive landscape, key risks, and potential approaches. Give me a SWOT analysis and a recommended strategy."

Twenty minutes later, I had a structured analysis that covered angles I hadn't considered. Was it exhaustive? No. Was it a dramatically better starting point than a blank page? Absolutely. For me, the key was that it gave me something to react to rather than having to create from scratch.

Professional communication

Need to draft a sensitive email? Give the AI the context, the relationship, the desired outcome, and the tone. First drafts that used to take me 30 minutes of careful wordsmithing now take 2 minutes of context-setting and 5 minutes of refinement. (Well, sometimes 10 minutes — I can be a bit perfectionist about tone.)

The key insight: you're not outsourcing thinking. You're outsourcing the translation from "I know what I want to say" to "here's a well-structured way to say it."

Research and analysis

Competitive analysis, market sizing, technology comparisons — all tasks where Copilot's breadth of knowledge shines. The beauty of this is that you get a comprehensive overview in minutes that would take hours to compile manually. The downside is that you won't get proprietary data or cutting-edge insights — so always verify the important bits against primary sources.

Reading and learning in your native language

One evening I needed to digest a book on philosophy that was relevant to a project I was working on. Instead of spending hours reading and note-taking, I asked Copilot — in Dutch — to give me a comprehensive summary covering the key arguments, practical applications, and how they connect to my work context. (I knew very well that a summary doesn't replace actually reading the book, but for my purposes it was more than enough.)

The result wasn't a shallow bullet list. It was a structured analysis that let me decide which chapters deserved a deep read and which I could skip. This is the kind of task that perfectly illustrates domain expansion: it has nothing to do with code, nothing to do with work in the traditional sense, but it made me more effective at both.

Connecting to your actual data: WorkIQ

A breakthrough moment came when I discovered that Copilot could connect to my actual work data. Through a feature called WorkIQ, I could ask questions about my own emails, calendar, and files — not hypothetical questions, but "what did my manager ask me about last Thursday?" or "summarize the key decisions from yesterday's meeting."

This collapsed the gap between "AI that knows things in general" and "AI that knows my things." It turned Copilot from a smart stranger into an informed colleague. I have been using this almost daily since, and it's one of those things where you wonder how you ever managed without it.

The "context is everything" principle

This phase taught me the single most important lesson about working with AI (and if you ask me, this applies to pretty much every AI tool out there): the quality of your output is a direct function of the quality of your input.

Vague prompt → vague output. Detailed prompt → surprisingly good output.

Here's a practical framework I developed:

Element	Why it matters	Example
Situation	Grounds the response in your reality	"I'm a tech consultant evaluating..."
Audience	Shapes tone, depth, and terminology	"This is for a C-level executive who..."
Goal	Focuses the output on what you need	"I need to decide whether to invest..."
Constraints	Prevents impractical suggestions	"Budget is limited, timeline is 3 months"
Format	Gets output you can actually use	"Give me a prioritized table with..."

You don't need all five every time. But the more you provide, the less you need to iterate.

Why this matters more than you think

Here's the thing about domain expansion: to me, the biggest productivity gains often come from tasks you were procrastinating on.

Code tasks? You were probably doing those anyway. But that strategic analysis you've been putting off? The competitor research you told yourself you'd get to "next week"? The professional email you've been avoiding because the wording needs to be just right?

Those are the tasks where AI changes the game. Not because it does them perfectly, but because it eliminates the activation energy. The blank page disappears. You go from "I should really do that" to "here's a solid first draft to refine" in minutes.

You might be in this stage if:

• You use AI confidently for code but haven't tried it for other types of work
• You have tasks you keep postponing because they're outside your technical comfort zone
• You write short, context-light prompts and get mediocre results
• You think of AI as a "coding tool" or "developer tool"

The compound effect

In Part 1 I said the early wins were small. By this stage, the compound effect kicked in. Not because any single task was 10x faster — but because I was now using AI for so many different types of tasks that the aggregate time saved became significant.

The shift from "AI helps me code" to "AI helps me think" is not a marketing slogan. It's a genuine change in how you approach work. And it happened not through some revelation, but through the simple act of asking: "I wonder if it can handle this too?"

The answer, more often than not, was yes 😊.

Try this week

Use AI for three tasks that have nothing to do with code this week. Some ideas:

• Draft a professional email you've been putting off
• Ask for a structured analysis of a business decision you're facing
• Have it audit or review something (a document, a plan, a proposal)

For each task, use the context framework: situation, audience, goal, constraints, format. Notice how the output quality changes when you provide more context.

Pro Tip: Start with the task you've been procrastinating on the longest. That's probably the one where the "blank page problem" is strongest — and where AI will make the biggest difference.

---

In Part 4 , I'll cover the most transformative phase: when I stopped using AI for individual tasks and started using it to automate my entire infrastructure and deployment pipeline. From accidental secret commits to designing security architectures — in eight weeks.

This is Part 3 of the My GitHub Copilot Journey series.

Now go ask GitHub Copilot something ambitious. 🚀

Kr, Tim