DEV Community: Bala Madhusoodhanan

Your Next Career Move May Already Be in Your Work: Discovering Career Evidence with Work IQ

Bala Madhusoodhanan — Mon, 31 Aug 2026 07:24:24 +0000

Intro:
You see a target role that feels like a leap. Your current experience is rooted in one specific domain, but the new role asks for a blend of strategy, leadership, and cross-functional capabilities that seem just out of reach.

At first glance, the instinct is familiar to many of us:
“My current job title does not match. I am not qualified.”

But that is the wrong question to ask. Instead of asking if your current title matches the role, the better question is:

“What capabilities is this role actually hiring for—and what evidence already exists in my work?”

That is where Microsoft 365 Copilot and Work IQ become surprisingly useful. Work IQ helps Copilot use authorised work context—such as relevant files, emails, meetings, chats, people, and work relationships—to provide a grounded response. Using / references, you can focus Copilot on specific priority material, such as a performance review, a major project wrap-up, and the target job description.

The Problem with Traditional Career Planning
Most of us assess our career readiness through static artefacts:

Our job title
Our current CV
An organisational chart
A formal job description

These documents are useful, but they are fundamentally incomplete. They show what you have historically been hired to do. They rarely capture:

What complex problems people increasingly bring to you
How you manage ambiguity and align stakeholders
The cross-functional projects you are driving
The leadership capabilities you are developing before a promotion formally recognises them

Your next role may be visible in your day-to-day work patterns long before it makes it onto your CV. Job titles are just labels; capabilities are evidence.

A senior or stretch role is rarely hiring just for domain expertise. It is looking for individuals who can define roadmaps, govern risk, translate strategy into delivery, and move an organisation from experimentation to scale. Those capabilities exist across many roles, even if the job titles look completely different.

The goal of this exercise is not to use Copilot to artificially convince yourself you are ready. The goal is to objectively separate your background into three categories:

Demonstrated experience: Capabilities you have explicitly executed and delivered.
Adjacent experience: Work you have done that is highly comparable and transfers directly to the new context.
Development gaps: Genuine areas where you lack evidence and need to build skills.

Prompt: Decode the Role and Map Your Evidence
Use this prompt as the first step in your career transition journey.

Act as a recruiter and career coach.

Analyse the target job description attached below and identify:

Core responsibilities

Hiring goals and business outcomes

Technical, strategic, and leadership capabilities being assessed

Important ATS keywords

The characteristics of a successful candidate

Then, use the Work IQ experience in Microsoft 365 Copilot to analyse my authorised work context for relevant evidence. Consider relevant work files, meetings, emails, Teams conversations, project activity, and stakeholder interactions that I am permitted to access.

Use the items I attach with / as priority evidence.

Create a table with these columns:

Target capability (from the JD)

Evidence from my work context

Source or cited work item

Why the evidence is transferable

Classification: demonstrated experience, adjacent experience, or development gap

Do not invent experience or outcomes. Clearly distinguish documented evidence from reasonable inference. Be honest about gaps.

What to Attach Using / References
To get the best results, start small and specific. Good first attachments include:

Your current CV
The target job description
Your latest performance review
A major project summary, business case, or closure presentation
A documented stakeholder feedback email

Decoding the Output
When you run this prompt, the output shifts your perspective from "Do I have the title?" to "Do I have the proof?" Here is an example of what that output might look like regardless of your specific industry:

Target Capability	Evidence from Existing Work Context	Classification
Cross-Functional Leadership	Chaired the weekly steering committee, aligning three distinct departments on the Q3 delivery schedule and resolving resource bottlenecks.	Demonstrated experience
Strategic Roadmapping	Authored the business case and phased rollout plan for the internal tool migration, translating user pain points into a delivery timeline.	Adjacent experience
Enterprise Governance	Established the risk review matrix used by the wider team to evaluate third-party vendors before onboarding.	Demonstrated experience
Executive Communication	Drafted monthly status briefings for the VP group, synthesising complex project metrics into clear, decision-ready updates.	Demonstrated experience
Specific Platform Expertise	Limited evidence of direct hands-on configuration or certification in the target proprietary software.	Development gap

Using Work IQ Responsibly
A career mapping exercise should be handled carefully when using enterprise tools:

Use only information you are authorised to access.
Do not use confidential work content (like financial data or proprietary architectures) in external job applications.
Verify all evidence and citations before relying on them.
Treat Copilot as a reflection and drafting partner, not the final decision-maker.

Choose one stretch role that interests you this week. Do not start by rewriting your CV. Start by asking what capabilities the role actually requires, and let your existing work provide the evidence. In the next article, we will take the evidence you uncover and turn it into a compelling CV and LinkedIn narrative.

Designing Intelligence: From Ad-Hoc Prompts to Enterprise AI Skills

Bala Madhusoodhanan — Mon, 24 Aug 2026 05:31:33 +0000

Intro:

The pattern now as part of agentic design is, we are witnessing a shift from treating Large Language Models purely as conversational interfaces to integrating them as governed architectural components. For developers using platforms like Microsoft Copilot Studio, understanding the transition from an ephemeral prompt to a persistent AI skill is critical for building scalable, compliant solutions.

Ephemeral Prompts vs. Persistent Skills:

A prompt is how you get started; a skill is how your team scales. Prompts are reactive, natural language instructions used for one-off tasks.
Context is completely forgotten when the session ends. Conversely, an AI Skill in Copilot Studio is a reusable, persistent workflow package—often defined as a Markdown file with YAML metadata—that loads on demand. A skill functions as an auditable microservice with standing system instructions, strict operational boundaries, and embedded operating logic.

Dimension	Prompts	Enterprise AI Skills
Use Case	One-off, exploratory tasks.	Executing standardized, highly repeatable processes safely.
Composition	Pure natural language prose lacking boundaries.	Hybrid: Markdown instructions combined with executable scripts.
Governance	Unmonitored compliance gaps.	Auditable assets enabling Risk Management and Human Oversight.

Not every task warrants becoming a skill. Unchecked "skill sprawl" leads to heavy maintenance debt and unnecessary token consumption. Use this decision tree to evaluate whether an automation request requires a simple prompt action or a formal enterprise skill.

Core Design Principles for Copilot Studio
To maintain a clean architecture, evaluate potential skills against these core system design principles:

The Rule of Two: If a prompt is typed more than twice for a team workflow, formalize it into a skill to guarantee output consistency.
Hybrid Execution Logic: Separate probabilistic reasoning from deterministic execution. Let the LLM handle context while Python scripts, APIs, or Power Automate flows execute rigid calculations.
Carbon-Aware Routing: When a workflow carries high regulatory demands, a managed skill is non-negotiable. To offset the computing footprint of persistent skills, deliberately route mechanical tasks to less energy-intensive models or execute batch operations during periods of lower grid carbon intensity.
Context Management: Design skills with highly optimized descriptions. Copilot Studio uses this metadata to decide when to dynamically pull the full skill instructions into the context window, reducing token cost and latency.
Traceability for Compliance: Align with frameworks like the EU AI Act by designing skills that enforce programmatic safety boundaries, telemetry, and human-in-the-loop triggers before execution.

Closing Thoughts: The Trap of "Easy"

As platforms like Copilot Studio lower the barrier to entry, building an AI Skill has never been easier. But just because you can build a skill does not mean you should.

The ease of low-code development often tempts citizen developers into "skill sprawl"—productizing every minor prompt into a persistent agentic workflow simply because the platform makes it simple to do so. This is an architectural trap. Not every task requires a governed microservice. As Mikko Koskinen’s real-world cost testing brilliantly highlights, defaulting to premium orchestrated agents for simple tasks can rapidly multiply your operational expenditure through stacked message consumption.

True system design is about restraint. Ad-hoc prompts remain a perfectly valid, highly cost-effective tool for daily friction, personal productivity, and exploratory work. Reserve the rigorous engineering of a persistent Skill for processes that truly demand strict boundaries, regulatory compliance, and repeatable, team-wide accuracy.

Unshakeable - Ancient Wisdom for Modern Resilience

Bala Madhusoodhanan — Mon, 17 Aug 2026 07:30:52 +0000

For those who have read my book, Ctrl+Alt+Dharma: Ethical AI through an Ancient Lens), you know I spent years researching how ancient Indian philosophical frameworks—specifically the Bhagavad Gita—can serve as a moral compass for modern artificial intelligence. In enterprise architecture, we use these ancient truths to mitigate algorithmic bias, design ethical workflows, and ensure our technology serves humanity.

Where my work focuses on building a resilient target architecture for enterprise AI, the author of this book Vivek has written the ultimate field guide for building a resilient target architecture for the human mind.

What makes Unshakeable so brilliant is its practicality. It doesn't just offer philosophical platitudes; every chapter ends with a highly specific "Move" to put the concept into immediate practice.

Whether you are a tech professional trying to avoid burnout, a leader looking to build a more resilient team, or simply someone trying to find your own "Dharma" in a chaotic world, this book is a mandatory read. It is a powerful reminder that before we can build intelligent, ethical systems, we must first build unshakeable minds.

Unshakeable

Have you read it yet? Let me know your thoughts in the comments, or share what ancient philosophies you rely on to navigate the modern world!

From Clicks to Documentation: Converting D365 Task Recordings into L4 Guides

Bala Madhusoodhanan — Mon, 10 Aug 2026 08:15:39 +0000

Intro:
Documenting business processes in Dynamics 365 can be time-consuming. Functional consultants and process owners often need to turn Task Recorder recordings into step-by-step user guides, training material, and Level 4 (L4) work instructions.
The challenge is that a Task Recorder file captures the system interaction, but it is not always ready to share as a polished business document.
To help with this, I created the axtr-to-markdown skill. It converts Microsoft Dynamics 365 Task Recorder recordings into structured Markdown documents that can be reviewed, enriched, published, or used as knowledge sources for Copilot Studio agents.

What is the axtr-to-markdown skill?
The axtr-to-markdown skill takes a Dynamics 365 Task Recorder file and transforms the recorded process into a structured Level 4 process training document.
It extracts available process information such as:

Process title and description
Recorded user steps
Form and screen names
Field or control names
Recorded values
Action types such as click, input, select, navigate, validate, save, and post

The output is a Markdown file that provides a much better starting point for a user manual than a raw Task Recorder export.
Key Features

AXTR to Markdown conversion Converts Dynamics 365 Task Recorder content into an editable Markdown document.
Level 3 and Level 4 support Generates either a concise SOP-style L3 document or a detailed click-by-click L4 work instruction.
Structured process documentation Includes purpose, scope, prerequisites, roles and responsibilities, detailed steps, expected outcomes, troubleshooting, related documents, and revision history.
SIPOC analysis draft Produces a draft Suppliers, Inputs, Process, Outputs, and Customers overview based on the available recording data.
Metadata options Add a custom document title, author, department, process level, and output location.
Copilot Studio-ready output Markdown documents can be used as a starting point for SharePoint knowledge articles, controlled documentation, or agent knowledge sources.

Why AXTR files are useful for L4 documentation
A Level 4 document focuses on the exact way a user performs a task in the system.
Dynamics 365 Task Recorder captures those practical details while a user completes the process. This makes AXTR-based documentation particularly useful for:

Standard operating procedures
End-user training guides
Onboarding documentation
Process harmonisation
UAT test-script drafting
Regression-test documentation
Support and issue-reproduction steps

Instead of starting with a blank Word document and manually transcribing every click, teams can use the recording as the baseline and focus their time on validating the business context, controls, exceptions, and approvals.

axtr-to-markdown

axtr-to-markdown/
├── scripts/
│   ├── axtr_to_markdown.py
│   └── helpers.py
├── references/
├── assets/
└── SKILL.md

The axtr-to-markdown skill does not attempt to replace process experts. Instead, it removes the repetitive first step of documenting every click and screen interaction manually.
It turns a Dynamics 365 Task Recorder output into an editable Markdown draft that functional consultants, business users, and process owners can review and enrich. The result is a faster route from recorded system activity to a maintainable L4 work instruction.

Build Repeatable AI Workflows with SharePoint Skills

Bala Madhusoodhanan — Mon, 03 Aug 2026 06:56:52 +0000

Many SharePoint tasks are repetitive: checking whether a project folder contains the right files, reviewing documents against a checklist, or finding knowledge articles that are overdue for an update.

SharePoint Skills are designed for exactly this kind of work.
A Skill is a reusable, multi-step AI workflow that runs inside SharePoint. Rather than writing code or building a conventional automation flow, you describe the outcome you want in natural language, then review and refine the Skill SharePoint generates.

You can also manage Skills directly from the SharePoint site’s Agent Assets library. Navigate to:

SharePoint site → Site contents → Agent Assets → Skills

From the Skills folder, you can manually upload a Skill file or organize existing Skills alongside your team’s other agent resources. This is useful when you want to reuse a Skill created elsewhere, maintain a controlled library of approved Skills, or move tested Skills between sites. Ensure users have the appropriate SharePoint permissions, since Skills operate within the site’s existing access model.

A simple example
In this example, the Skill reviews each vendor onboarding folder for a signed NDA, tax form, and onboarding checklist. It then returns a clear summary of complete folders and folders that require attention. This replaces a repetitive manual review with a consistent, reusable AI-assisted process.

Why this improves the experience

Skills make SharePoint more approachable because users do not need to remember complicated processes or learn a scripting language. They can simply ask for the outcome in the language they already use.
For example:

“Check the Plans library for project folders missing an approved brief or final budget, and list the gaps.”

Once saved, a Skill is reusable by people with the appropriate site access. Users can invoke it through a matching natural-language request, without necessarily having to remember the Skill’s exact name.

Keep the first Skills focused
The best first use cases are specific, repetitive, and easy to verify:

Folder completeness check — Find missing mandatory files.
Document quality review — Check documents against an internal checklist.
Content freshness audit — Identify pages or documents that need review.
Naming and metadata review — Highlight content that does not follow team standards.

Start small, test with real documents, and improve the wording based on how your team actually asks questions.

What Skills are not

Skills are not intended to replace every automation platform. They work within SharePoint and inherit the permissions of the person running them. They cannot call external APIs, trigger webhooks, or run custom code. For cross-system workflows or transactional business automation, Power Automate or Copilot Studio may be the better fit.

The magic is not just AI—it is turning a well-understood team process into something everyone can use consistently.

For the official product documentation

Less Doing, More Living

Bala Madhusoodhanan — Mon, 27 Jul 2026 11:16:55 +0000

The core philosophy of Less Doing, More Living boils down to a systematic approach for reducing operational friction and freeing up high-value time.

Enhancing AI Governance with the ai-governance-classifier Skill

Bala Madhusoodhanan — Mon, 20 Jul 2026 05:43:28 +0000

Intro:
AI is transforming how we interact, but with great power comes great responsibility. Ensuring responsible AI behavior—especially around sensitive data—is crucial. In this post, I’ll introduce the ai-governance-classifier skill, explain how it works, and show practical examples of its value.

The ai-governance-classifier skill is a tool designed to help conversational AI agents comply with governance policies. It automatically analyzes user queries to detect whether they involve personal information or restricted topics. If a query is sensitive, the agent declines to answer, protecting privacy and ensuring compliance.
Key Features:

Automated Classification: Detects personal or sensitive queries.
Policy Enforcement: Blocks responses when necessary.
Customizable Messaging: Lets you tailor blocked response messages.

Setup:

1) Before responding to any user message, always call the skill: ai-governance-classifier  

2) The skill will return a JSON object. Parse the output and evaluate the following fields:
ClassifyPersonal
ClassifyBias

3) If the skill output contains "ClassifyPersonal": "Yes" OR "ClassifyBias": "Yes":
   → Do NOT answer the user's original question.
   → Do NOT display the JSON output.
   → Respond ONLY with: "This Agent doesn't respond due to AI governance policy."
   → Stop processing immediately.

4) If the skill output contains "ClassifyPersonal": "No" AND "ClassifyBias": "No":
   → Proceed to answer the user's question normally.
   → Do NOT display or reference the JSON output in your response.‌

Examples:

Why Use ai-governance-classifier?

Protects User Privacy: Sensitive information isn’t exposed or mishandled.
Supports Regulatory Compliance: Helps meet GDPR, CCPA, and other requirements.
Builds Trust: Users see that their data is respected.
Reduces Risk: Prevents accidental leaks or misuse of information.
Easy Integration: Works with existing conversational agents with minimal setup.

AI governance isn’t just about rules—it's about protecting people. The ai-governance-classifier skill makes it easy for AI agents to act responsibly, balancing usefulness with privacy. Try it out and experience the peace of mind that comes from trustworthy AI.

Link to Skill: GitHub Repo

Automating RAG Regression Tests with an AI-Driven Evaluator (AI Builder + Copilot Studio)

Bala Madhusoodhanan — Mon, 13 Jul 2026 09:39:32 +0000

Intro:
We built a lightweight regression-testing pipeline for our Retrieval-Augmented Generation (RAG) agent using Power Automate, Copilot Studio (or Execute Agent), and an AI Builder evaluation prompt. The goal: turn a curated set of knowledge-base (KB) questions into a repeatable test pack, run them automatically after KB or instruction changes (or model upgrades), and deliver deterministic pass/fail reports to the product owner.

How it works (high level):
Work with the product owner to define a small, focused regression pack: representative KB questions + the expected/desired responses or required attributes (formatting, tone, required facts). Keep these single-turn questions to start.

Store the test pack (Excel/Dataverse/SharePoint list). Each row is a test case: ID, question, expected snippet or attributes, and acceptance criteria.
Automate with Power Automate (flow shown in the screenshot): a) Manually trigger or schedule the flow. b) GetTestCases (read test pack from Excel/Dataverse). c) Scope > Apply to each test case: d) Compose input payload (question + metadata). e) Execute Agent and wait (run the RAG agent for that single-turn question). f) Run a prompt (AI Builder or LLM) that evaluates the agent response against the acceptance criteria.

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

Bala Madhusoodhanan
Bala Madhusoodhanan

Bala Madhusoodhanan

Follow

May 25

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

#aibuilder #powerplatform #evaluation #powerfuldevs

5 reactions
Add Comment

4 min read

Update a row with the result (Pass/Fail, metrics, evaluator JSON).
After loop: aggregate results, calculate pass rate, and send a report to the product owner (email/Teams/Files).

The evaluation prompt (core idea) We used an evaluator prompt that positions the LLM as an impartial critic and returns a strict JSON evaluation. This is inspired by proven LLM-as-judge patterns and gives us a deterministic, machine-readable output to gate deployments.

Output is machine-readable (JSON/CSV) so results can be tracked and automated.
Each test shows scores and a short reason so the product owner sees why something failed.
Clear PASS/FAIL and a short failure reason make go/no-go decisions easy. Every result links back to the original test case so fixes are quick to find.
Include run info (date, model/KB version) so failures can be reproduced.
Show a one-line summary (e.g., "28/30 passed — 93%") for a fast health check.
Prioritize failures by impact so the product owner knows what to fix first.
Attach remediation notes (short next steps) so engineers know how to resolve issues.

A clear, structured evaluation report turns a flood of agent outputs into actionable intelligence — empowering product owners to make fast, confident decisions about content changes, model updates, and releases.

Ask, Filter, Deliver: Interactive Work Item Exploration for Product Teams

Bala Madhusoodhanan — Mon, 06 Jul 2026 07:06:21 +0000

Intro:
Product teams often face the challenge of sifting through a mountain of work items in Azure DevOps (ADO), searching for the signal amid the noise. Whether you’re validating a new requirement, checking the status of a change request, or planning for the next release, actionable insights—delivered quickly—are key.
This article explores how to leverage Power Automate’s connectors in an agentic workflow, enabling interactive exploration of work items. We’ll start with the quickest way to get started, then dive deeper into more advanced filtering and dynamic queries.

Quick & Easy: Using a Pre-Defined Query
For teams looking for a fast solution, Power Automate offers a simple method: use a pre-defined ADO query and connect it directly to your workflow. This approach is perfect when you already know the criteria you want to retrieve—such as all work items assigned to your team, or those marked as “New” or “Change Request.”

1) Setup the ADO query and get the system generated query ID

2) Use the ADO get query action and

3) Use this as a Tool to get the data into agentic workflow and let the orchestration engine do its magic to work on the data

If your pre-defined query returns too many work items, you may encounter errors or timeouts in your agentic workflow due to Power Automate’s data handling limits.

Dynamic Querying for Flexible, Context-Aware Exploration:
When you need more flexibility than a static, pre-defined query allows, it’s time to move to dynamic querying. This method lets your agentic workflow adapt on the fly—filtering data right at the source based on user input or real-time context.
Instead of relying on a single saved query, you dynamically build your ADO query, often using variables from Copilot prompts or Power Automate inputs. This makes your flows far more interactive and resilient—especially for product teams who need answers to specific, changing questions.

1) Use the “Send an HTTP request to Azure DevOps” Action

2)Build Your WIQL Query Dynamically
In the request body, construct your WIQL query.
Use dynamic content (variables, user responses, or Copilot inputs) to substitute values—like work item type, title, or state.

{
  "query": 
"SELECT [System.Id], [System.Title], [System.State]
            FROM WorkItemLinks
            WHERE [Source].[System.WorkItemType] = 'Capability'
            AND [Source].[System.Title] CONTAINS '@{triggerBody()?['text']}'
            AND [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward'
            AND [Target].[System.WorkItemType] = 'Business Requirement'
            AND [Target].[System.State] <> 'Removed'
            MODE (MayContain)"
}

The server only returns data that matches your specific, real-time criteria

When using this method, always validate user input and test query performance to ensure your workflow remains fast and reliable, even as requirements change.

Pre-Defined Query	Dynamic Query (HTTP Request)
Pros	Pros
Fast to implement and easy to maintain	Highly flexible—query adapts to user or agent input in real time
Reliable for routine, repeatable queries	Efficient—returns only what’s needed, minimizing risk of timeouts/data overload
No need for advanced query skills	Supports complex, cross-linked queries for richer insights
Cons	Cons
Static: limited flexibility; not responsive to changing needs	Requires understanding of WIQL and Azure DevOps REST API
If the query returns too much data, you may encounter errors or timeouts in your agentic workflow due to Power Automate’s data handling limits	More setup and testing needed
Updates require manual changes in Azure DevOps	Errors can occur if dynamic input is invalid or query structure is incorrect

Bottom Line:
Pre-defined queries are great for stable, repeatable needs and quick wins.
Dynamic queries empower truly interactive, agentic workflows—perfect for evolving product management and backlog exploration.

PS - The oDATA options is something to be explored

Automating Your Weekly Prep with an AI-Powered M365 Briefing with WorkIQ

Bala Madhusoodhanan — Tue, 30 Jun 2026 07:34:00 +0000

Intro:
We've explored the immense potential of Copilot to transform our daily workflows. But what if you could start every week not just prepared, but truly proactive? What if the overwhelming feeling of a Monday morning inbox, the forgotten follow-ups, or the surprise meeting tasks could become a thing of the past? We spend precious hours just sifting through emails, cross-referencing calendars, and trying to recall commitments, all before we even get to the actual work. Here is something evolved over time and the quality of response is amazing when workIQ is enabled.

Structure of the Prompt:
Most productivity loss doesn't happen because people are lazy — it happens because of invisible overhead: the mental energy spent remembering what's pending, deciding what to do next, or realising on Wednesday that something sent on Friday never got a response. This prompt eliminates that overhead systematically

Problem it solves	How
Inbox anxiety	Every actionable thread is surfaced and ranked — nothing lurks
Forgotten follow-ups	Sent Items review catches every unanswered request you made
Meeting unprepared	Category A/B meeting prep flags what needs doing before you walk in
Time blindness	The capacity overview shows next week's shape before it happens
Reactive Mondays	You start the week with a plan, not a pile
Manager communication gaps	The status draft means you never skip this because it takes too long
Distraction patterns	The productivity summary names the patterns so you can change them

GLOBAL SCOPE RULES (apply to every section below)

| Rule | Definition |
|---|---|
| **My identity** | From = me; "To me" = I appear in the To field (not Cc/Bcc only) |
| **Lookback** | Past 7 calendar days from the moment this prompt runs |
| **Lookahead** | Next 7 calendar days from the moment this prompt runs |
| **Deduplication** | Deduplicate conversation threads; represent each thread once using its latest qualifying message |
| **Internal domain** | Infer my organisation's domain from my email address; all other domains = External |
| **Automated exclusions** | Drop items from: noreply / no-reply / do-not-reply / no_reply senders; Teams notification emails (noreply@*.teams.microsoft.com); system alerts; OOO auto-replies (for response-detection only); digests; newsletters; bulk marketing |
| **Broadcast exclusions** | Drop subjects containing: E-Learning, Training reminder, Newsletter, Digest, Notification, Alert, System message, FYI only, Do not reply |
| **Calendar invite exclusions** | Drop calendar auto-notifications unless the body explicitly requests a non-calendar action |

---

## 📤 OUTPUT STRUCTURE

Produce the full report in this exact sequence of sections:

---

### SECTION 1 — 📥 INBOX: Outstanding Actions (Lookback 7 days)

**Purpose:** Surface every email in my Inbox that still requires action from me.

**Scope:**
- Folder: Inbox only (no subfolders, Archive, Junk, Deleted Items)
- Include only threads where I am on **To** (not Cc/Bcc only)
- Represent each thread once using the **latest inbound message** within the lookback window
- Apply all global exclusions above

**Inclusion logic (three tiers):**

| Tier | Condition |
|---|---|
| **@Mentions** | I am explicitly @mentioned in the message body |
| **Unread** | Message is Unread (including "seen on mobile but still Unread") |
| **Read – not replied** | Message is Read but I have NOT sent a reply after the latest inbound (compare my latest Sent timestamp in the thread vs. the latest inbound timestamp) |

**Prioritisation within section:**
1. @Mentions (newest → oldest)
2. Unread, no @mention (newest → oldest)
3. Read, not replied (newest → oldest)

**Output format:**

Start with the heading:

📥 Immediate Action — Inbox

Provide a single continuous numbered list across all tiers.
- Prefix @mention items with **‼️**
- For each item include: **Bold subject**, Sender (display name), Received date/time (local), one-line **Next step**

Then the heading:

📥 Action Required — Inbox

Remaining qualifying items in the same format.

Then:

📥 Other — Inbox

All examined inbox threads NOT included above: Sender – Subject – Received date (to confirm nothing was missed).

---

### SECTION 2 — 📨 SENT ITEMS: Awaiting Responses (Lookback 7 days)

**Purpose:** Surface emails I sent that requested action and have not yet received a meaningful response.

**Scope:**
- Folder: Sent Items only
- From = me; deduplicate threads; use my latest sent message per thread within the lookback window
- Apply all global exclusions

**Inclusion logic:**
- Include only emails where I **requested input, a decision, or a deliverable** (proposal, data, approval, feedback enabling next steps)
- Exclude emails where I only asked for simple confirmation ("Is this okay?") → move to Other
- Exclude emails where I only provided information/deliverables with no expectation of a reply → move to Other
- If mixed informational + action-request content, treat as **action-request**

**Response detection (per thread):**
- Check Inbox for any inbound reply **after** my latest sent timestamp in that thread
- Ignore OOO auto-replies for response detection
- Mark as **"No response yet"** if no qualifying inbound reply exists
- Mark as **"Responded – further action needed"** if an inbound reply exists AND that reply itself requests further action from me

**Prioritisation:**
1. Sent items where I explicitly **@mentioned** a recipient (and requested action) — newest → oldest
2. Sent items requesting action, **no response yet** — newest → oldest; same date → alphabetical by subject

**Internal vs External classification:**
- If ANY recipient is outside my organisation's domain → **External**
- Otherwise → **Internal**

**Output format:**

📨 Immediate Action — Sent Items

🌐 External

🏢 Internal

Prefix @mention items with **‼️**. Numbering is continuous across External + Internal (do not restart).

For each item include: **Bold subject**, Recipient(s) summarised, My latest sent date/time (local), Response status, first ~10 words of my sent body as a snippet, one-line **Next step** (include what I asked for).

📨 Action Required — Sent Items

🌐 External

🏢 Internal

📨 Other — Sent Items

All examined sent threads NOT included above: Recipient(s) – Subject – Sent date.

---

### SECTION 3 — 💬 TEAMS: Unanswered Mentions (Lookback 7 days)

**Purpose:** Surface Teams conversations where I was mentioned and have not replied.

**Scope:**
- Scan all Teams chats and channels where my name was **@mentioned** in the lookback window
- Exclude threads where I have replied **after** the mention
- Exclude automated bot messages and system notifications

**Output format:**

💬 Teams: Unanswered Mentions


For each item: **Bold conversation/channel name**, Mentioned by (display name), Date/time (local), Message snippet (~10 words), one-line **Next step**.

If nothing qualifies: state explicitly.

---

### SECTION 4 — 📊 LOOKBACK PRODUCTIVITY SUMMARY (Past 7 days)

**Purpose:** A concise, honest picture of how I spent my time and where I was most/least productive. Ground in Work IQ / Viva Insights data where available.

Produce the following sub-sections:

#### 4a. ⏱️ Time Distribution — How I Spent My Week

Analyse my calendar and meeting data for the past 7 days. Create meaningful categories that describe how I used my time (e.g., Deep Work, Internal Meetings, External Meetings, 1:1s, Admin & Planning, Learning, Unstructured/Fragmented time). For each category provide:
- Category name and a one-line description
- Estimated hours spent
- Estimated % of working time
- A brief assessment (e.g., "Well-balanced", "Potentially over-indexed", "Under-invested")

Present as a formatted table, then a short paragraph narrative.

#### 4b. 🏆 Key Wins & Decisions Made

List the 3–5 most significant outcomes, decisions, or deliverables completed in the past 7 days. Draw from email threads (closed action items), meeting notes/outcomes, and Teams conversations. Be specific and concise.

#### 4c. 🚧 Blockers & Escalations Identified

List items where progress stalled because I am waiting on others, or where a decision is overdue. Reference the relevant email/thread/meeting so I can act immediately.

#### 4d. 🔍 Collaboration & Interaction Highlights

Summarise the key people I collaborated with most intensely this week (internal and external). Note any collaboration patterns worth paying attention to (e.g., disproportionate time with one stakeholder, gaps in outreach to key contacts).

#### 4e. ⚠️ Distractions & Interruptions

Identify patterns that may have reduced focus time:
- High volume of ad-hoc meeting invitations accepted
- Fragmented calendar blocks (< 30 min between meetings)
- High email response rate outside core hours
- Teams message spikes during deep-work blocks

Provide 2–3 **concrete suggestions** to reduce these distractions next week.

---

### SECTION 5 — 📝 MANAGER STATUS UPDATE DRAFT (Lookback 7 days)

**Purpose:** A ready-to-send (or lightly edited) status update for my manager.

Draw from Sections 1–4 to draft a concise update. Format as an email body (no subject line needed — I will add that). Structure it exactly as:

📝 Draft: Weekly Status Update for My Manager


**Key Wins this week:**
(3–5 bullet points — specific, outcome-focused)

**Decisions Made / Closed:**
(2–3 bullet points — include who was involved)

**Blockers Needing Your Input:**
(List only items where manager action or awareness is genuinely needed; be direct about what you need from them)

**Focus for Next Week:**
(3–5 bullet points — drawn from Section 6 below)

Keep the tone professional but conversational. Total length: 150–250 words.

---

### SECTION 6 — 📅 UPCOMING WEEK: Meeting Preparation (Lookahead 7 days)

**Purpose:** Help me walk into next week fully prepared for every meeting that matters.

Analyse my calendar for the next 7 days. Apply the following classification:

#### Category A — Meetings I Organise (No Agenda Yet) ⚠️

List all meetings where I am the **organiser** and no agenda exists in the invite body. These need attention before the meeting. Sort by date (earliest first).

For each: **Bold meeting title**, Date/time (local), Attendees (summarised), one-line **Suggested agenda action** (e.g., "Draft and send agenda by [day]").

#### Category B — Meetings Where I Am Mentioned / Have Prep Tasks 📌

List meetings where I am **mentioned in the agenda** or where the invite body contains explicit tasks or action items assigned to me. Sort by date.

For each: **Bold meeting title**, Date/time (local), Organiser, the specific task or mention, one-line **Prep action**.

#### Category C — Other Relevant Meetings Requiring Attention 🔔

List any remaining meetings that do not fall into A or B but may still require my attention (e.g., strategic meetings, external client calls, presentations I am part of). **Exclude** routine recurring status meetings or check-ins unless I have a specific task.

For each: **Bold meeting title**, Date/time (local), Organiser, one-line **Why it matters / suggested prep**.

**Output heading:**

📅 Upcoming Week — Meeting Preparation

Category A: I Organise — No Agenda Yet

Category B: I'm Mentioned / Have Prep Tasks

Category C: Other Relevant Meetings


If a category is empty, state that explicitly.

---

### SECTION 7 — 🗓️ UPCOMING WEEK: Time & Capacity Overview (Lookahead 7 days)

**Purpose:** Give me a forward-looking picture of how my time is allocated next week so I can spot imbalances before they happen.

Using my calendar for the next 7 days:

1. **Estimated time in meetings** (hours and % of working week, assuming 40-hour week)
2. **Estimated free/focus time** available (hours and %)
3. **Busiest day** and **lightest day**
4. **Any back-to-back meeting chains** (3+ consecutive meetings with < 15 min break) — flag these explicitly
5. **Recommended focus blocks** — suggest 2–3 specific time slots (day + approximate time) where I should protect deep-work time based on my calendar gaps

Present as a short formatted summary with a brief planning recommendation at the end.

🗓️ Next Week — Capacity & Focus Planning


---

### SECTION 8 — ✅ CONSOLIDATED PRIORITY LIST (Action Checklist)

**Purpose:** One place to see everything I need to do, ranked by urgency. This is the section I act from.

Aggregate all action items from Sections 1–6. De-duplicate any items that appear in multiple sections. Rank using this priority order:

| Priority | Source |
|---|---|
| 🔴 Urgent | @Mentioned emails/Teams not replied + Sent items with deadline risk + No-agenda meetings happening in < 48 hours |
| 🟠 High | Unread emails requiring reply + Awaiting responses blocking progress + Meeting prep for Category A & B |
| 🟡 Medium | Read-not-replied emails + Category C meetings + Manager update draft |
| 🟢 Low / This week | Everything else identified in the report |

✅ Consolidated Priority List — Week of [Date]


Provide a single numbered list across all priorities. Format each line as:

`[Priority emoji] **[Action title]** — Source: [Section ref] — Due/By: [date or "ASAP"]`

---

## 🔒 FORMATTING & QUALITY RULES (apply globally)

- All section headings must appear exactly as written above
- Do not show full recipient/attendee lists — summarise (e.g., "3 recipients incl. [Name]")
- Do not expose email addresses in output — use display names only
- If a section has no qualifying items, state: *"Nothing to action here — you're clear."*
- Keep Next step recommendations to one line; be direct and specific (avoid vague verbs like "consider" or "look into")
- Flag any data gaps (e.g., if Teams data is unavailable, note it and skip that section gracefully)
- Total report should be scannable in under 10 minutes

Work IQ (Microsoft's Viva Insights / Workplace Analytics layer) is what transforms this from a email summary into a genuine productivity intelligence report. Here's specifically what it unlocks for each section:

Section	Without Work IQ	With Work IQ
Time Distribution (4a)	Rough estimates from calendar titles alone	Precise categorisation using meeting metadata, focus time signals, and collaboration patterns
Distractions (4e)	Generic observations	Actual data: after-hours email spikes, fragmented calendar blocks, meeting-acceptance rates, quiet hours violations
Collaboration Highlights (4d)	"You emailed these people"	Network analysis — who you over-collaborated with, who went dark, whether key stakeholders are being neglected
Blockers (4c)	Based on email threads only	Cross-referenced with task signals, missed response SLAs, and meeting outcomes
Capacity Planning (7)	Calendar gap counting	Focus time recommendations grounded in your actual historical deep-work patterns
Manager Update (5)	Reconstructed from memory	Drawn from verified activity data — wins and decisions have evidence behind them

What This Prompt Does
This is a single, scheduled intelligence briefing that runs every Sunday night and gives you a complete picture of the week behind you and the week ahead — without you having to open a single folder, scroll through a single inbox, or reconstruct anything from memory.
In one automated run, it:
Audits your Inbox — finds every thread that still needs action from you, ranked by urgency, with a suggested next step already written
Audits your Sent Items — surfaces emails where you're waiting on someone else, so nothing you kicked off gets forgotten
Scans Teams — catches any @mentions you haven't replied to, which are easy to miss when switching between channels
Summarises your past week — time distribution, key wins, blockers, collaboration patterns, and distractions — so you arrive Monday with self-awareness, not guesswork
Drafts your manager update — a ready-to-send status email built directly from your actual activity data, not from what you can remember on a Friday afternoon
Prepares you for every meeting next week — flags which ones have no agenda (and you're the organiser), which ones have tasks assigned to you, and which ones are strategically important
Maps your capacity — shows where your focus blocks are, where the back-to-back meeting chains are, and where to protect deep-work time before the week fills up
Produces one consolidated action checklist — a single ranked to-do list (🔴🟠🟡🟢) you can open Monday morning and act from immediately
The core idea is simple: you shouldn't have to do the triage yourself. The prompt does the triage; you do the thinking.

Augment intelligence i.e., you shouldn't have to do the triage yourself. The prompt does the triage; you do the thinking.

Transform Raw Data into Visual Insights in Copilot Studio with a Single Skill!

Bala Madhusoodhanan — Mon, 22 Jun 2026 05:42:44 +0000

Intro:
Your agent is a data powerhouse. It connects to APIs, pulls reports, and processes complex queries. But too often, the output looks something like this:

For the end users, this requires the user to actively parse, compare, and mentally visualize trends.

Now with the new Copilot Studio Run time engine, we could leverage Skills to enable this visualisation.

The "Data Visualization & Response Formatting": SkillMd

I've crafted a comprehensive SkillMd (a markdown-based skill definition) that you can drop directly into your Copilot Studio agent. This skill empowers your agent to:

Automatically Detect Data: When a response contains quantifiable data, the skill kicks in.
Smartly Select Charts: It intelligently chooses the best chart type (Pie, Bar, Line, etc.) based on the data's structure.
Render Visuals: It generates beautiful, interactive charts using Mermaid diagrams (which Copilot Studio supports natively!).
Pair with Precision: Every chart is accompanied by a precise markdown table for those who need exact figures.
Deliver Key Insights: It summarizes the most important trends and observations in plain language.
Propose Next Steps: It proactively suggests follow-up questions for deeper analysis.

In essence, this skill turns numbers into narratives. Anytime the agent detects data worth seeing — not just reading — it renders the right chart, pairs it with a precise table, and explains what the numbers mean. It activates automatically, so analysts and leadership get visual-first answers without having to ask.

markdown
# Skill: Data Visualization & Response Formatting

## Description

This skill enables the agent to render data points, metrics, and comparisons as **visual charts and graphs** alongside structured markdown tables. When a response involves quantifiable data (e.g., revenue, units, growth rates, period comparisons), the agent automatically selects the most appropriate chart type and renders it using supported formats such as **Mermaid diagrams**, **HTML/Chart.js snippets**, or **Python code blocks** (matplotlib/plotly) depending on the platform capabilities.


## When this skill is activated:

1. Identify that the user's query involves **quantifiable data points** (e.g., revenue, volume, rates, comparisons across periods or categories).
2. Determine the **most appropriate chart type** based on the data structure (see Chart Selection Guide below).
3. Render the chart using the best available format (Mermaid preferred for markdown environments).
4. Accompany every chart with a **supporting markdown table** containing the exact figures for reference and accessibility.
5. Provide a **"Key Insights"** section summarizing notable trends, highlights, or concerns in plain language.
6. End with a **proactive follow-up question** offering the user a logical next step for deeper analysis.


## Chart Selection Guide

| Data Scenario | Recommended Chart | When to Use |
|---|---|---|
| Comparing values across categories | **Bar Chart** (vertical) | 2–8 categories, single or dual metric |
| Showing change over time | **Line Chart** | 3+ time periods, trend identification |
| Showing proportion or share | **Pie / Donut Chart** | 2–6 categories, parts of a whole |
| Comparing two periods side by side | **Grouped Bar Chart** | Period-over-period comparison |
| Showing ranking or sorted performance | **Horizontal Bar Chart** | Ranking items by a single metric |
| Displaying distribution or variance | **Stacked Bar Chart** | Breakdown of a total across sub-categories |
| Single KPI or headline metric | **KPI Card (bold text block)** | One standout number with context |


## Rendering Formats (Priority Order)

### 1. Mermaid Diagrams (Preferred)
Use Mermaid syntax for environments that support it. Wrap in a fenced code block with `mermaid` language tag.

**Bar Chart Example:**

~~~
mermaid
xychart-beta
    title "Sales by Category — Current vs Prior Period"
    x-axis ["Category A", "Category B"]
    y-axis "Value" 0 --> 100
    bar [64.5, 16.4]
    bar [67.9, 16.2]

~~~plaintext

**Pie Chart Example:**

~~~
mermaid
pie title Share by Category — Current Period
    "Category A" : 54
    "Category B" : 31
    "Category C" : 15

~~~plaintext

**Line Chart Example:**

~~~
mermaid
xychart-beta
    title "Performance Trend Over Time"
    x-axis ["Period 1", "Period 2", "Period 3", "Period 4", "Period 5", "Period 6"]
    y-axis "Value" 50 --> 90
    line [62.3, 68.1, 71.4, 65.9, 67.9, 70.2]

~~~python

### 2. Python Code Blocks (Fallback)
If Mermaid is not supported, provide a ready-to-run Python code block using `matplotlib` or `plotly`.

~~~
python
import matplotlib.pyplot as plt

categories = ['Category A', 'Category B']
current = [64.5, 16.4]
prior = [67.9, 16.2]

x = range(len(categories))
width = 0.35

fig, ax = plt.subplots()
ax.bar([i - width/2 for i in x], current, width, label='Current Period', color='#1a1a1a')
ax.bar([i + width/2 for i in x], prior, width, label='Prior Period', color='#c4a35a')

ax.set_ylabel('Value')
ax.set_title('Performance — Current vs Prior Period')
ax.set_xticks(x)
ax.set_xticklabels(categories)
ax.legend()
plt.tight_layout()
plt.show()

~~~html

### 3. HTML/Chart.js Snippet (Web Environments)
For web-based agent interfaces that render HTML.


## Formatting & Style Rules

- **Always pair a chart with a data table** — charts for quick visual insight, tables for exact numbers.
- **Chart titles** must clearly state: metric, period, and unit of measure (e.g., *"Revenue — Current vs Prior Period (USD)"*).
- **Number formatting** in tables:
  - Currency: `$XX,XXX,XXX` (with commas)
  - Units: `XX,XXX` (with commas)
  - Percentages: `+X.X%` or `-X.X%` (always show sign)
  - Changes: prefix with `+` or `-` to indicate direction
- **Key Insights** should be **2–4 bullet points**, each tied to a specific visual observation.
- **Follow-up suggestions** should guide toward deeper or adjacent analysis.


## Examples

### Example 1: Multi-Category Period Comparison (Bar Chart + Table)

**User request:** *"Show me Category A and Category B results for the current period vs the prior period"*

**Expected behavior:**

> The agent renders a **grouped bar chart** comparing both categories across the two periods, followed by a detailed table:

~~~
mermaid
xychart-beta
    title "Revenue — Current vs Prior Period"
    x-axis ["Category A", "Category B"]
    y-axis "Revenue" 0 --> 80
    bar [64.5, 16.4]
    bar [67.9, 16.2]

~~~markdown

> **Revenue Summary**
>
> | Category | Current Period | Prior Period | Change ($) | Change (%) |
> |----------|---------------|--------------|------------|------------|
> | Category A | $64,461,922 | $67,850,448 | -$3,388,526 | -5.0% |
> | Category B | $16,449,638 | $16,162,736 | +$286,901 | +1.8% |
>
> **Key Insights**
> - **Category A** declined 5.0% — visible in the chart as a shorter bar vs the prior period.
> - **Category B** grew modestly at +1.8%, nearly flat visually but positive momentum.
>
> *Would you like a deeper breakdown by sub-category or a trend view across multiple periods?*


### Example 2: Trend Over Time (Line Chart)

**User request:** *"Show me the performance trend for the last 6 periods"*

**Expected behavior:**

> The agent renders a **line chart** showing the trajectory, followed by the data table:

~~~
mermaid
xychart-beta
    title "Performance Trend — Last 6 Periods"
    x-axis ["P1", "P2", "P3", "P4", "P5", "P6"]
    y-axis "Value" 50 --> 90
    line [62.3, 67.9, 70.2, 74.5, 68.1, 64.5]

~~~markdown

> | Period | Value | Period-over-Period Change (%) |
> |--------|-------|------------------------------|
> | P1 | $62,300,000 | — |
> | P2 | $67,900,000 | +9.0% |
> | P3 | $70,200,000 | +3.4% |
> | P4 | $74,500,000 | +6.1% |
> | P5 | $68,100,000 | -8.6% |
> | P6 | $64,500,000 | -5.3% |
>
> **Key Insights**
> - Performance peaked in **P4** at $74.5M before declining for two consecutive periods.
> - The downward trend (-8.6% → -5.3%) suggests softening performance — worth investigating the underlying drivers.
>
> *Would you like me to overlay a forecast line or break this down by sub-category?*


### Example 3: Proportional Share (Pie Chart)

**User request:** *"What's the share breakdown by category for the current period?"*

**Expected behavior:**

> The agent renders a **pie chart** showing proportional share:

~~~
mermaid
pie title Share by Category — Current Period
    "Category A" : 54
    "Category B" : 31
    "Category C" : 15
~~~

> | Category | Value | Share (%) |
> |----------|-------|-----------|
> | Category A | $285,400,000 | 54% |
> | Category B | $163,900,000 | 31% |
> | Category C | $79,300,000 | 15% |
> | **Total** | **$528,600,000** | **100%** |
>
> **Key Insights**
> - **Category A** is the dominant contributor at 54% of the total.
> - **Category B** contributes nearly a third — any softness here materially impacts the overall number.
>
> *Would you like to see how this split has shifted compared to the prior period?*


### Example 4: Data Not Available

**User request:** *"Chart the margin breakdown for this segment"*

**Expected behavior:**

> I'm sorry, margin data for that segment is not available in my current dataset. I can visualize **revenue** and **volume** breakdowns with charts and tables. Would that be helpful?


## Notes

- This skill activates **automatically** when the agent detects **2+ comparable data points** — the user does not need to explicitly request a chart.
- For **single data points** with no comparison, use a **KPI-style bold text block** instead of a chart, and prompt the user for a comparison dimension.
- **Charts and tables are complementary** — never render a chart without an accompanying data table.
- The **follow-up question** should guide toward a deeper or adjacent analysis, never repeating what was already shown.
- When the rendering environment doesn't support Mermaid, fall back to Python code blocks with clear instructions.
- All figures must be **grounded in source data** — never fabricate or estimate values to populate a chart.

plaintext

Empower your Copilot Studio agent with visual intelligence:

pie title Revenue Composition (Q1–Q3 2026)
    "Software (£)" : 20000
    "Hardware (£)" : 12000
    "Services (£)" : 7500

Navigating the New Copilot Studio: A "Good, Bad, and Nitty-Gritty" First Look

Bala Madhusoodhanan — Tue, 16 Jun 2026 07:23:00 +0000

Intro:
The latest iteration of Copilot Studio has landed (announced last week at MSFT BUILD 26, promising a transformative experience in agent building. As with any significant overhaul, it brings a mix of innovation and growing pains. To objectively assess this new landscape, let's apply a simple, yet powerful, mental model: the Good, the Bad, and the Nitty-Gritty. This framework helps us highlight the triumphs, confront the challenges, and identify the essential, sometimes less glamorous, tasks required to move forward.

Highlights (The Good): Embracing the Future of AI Agents
The new Copilot Studio shines brightest with its underlying technological advancements and user-centric features designed to streamline agent development.

A Powerful New Orchestrator: At its heart lies a robust orchestrator, powered by Claude, boasting direct access to Bash, Python, and Node environments. This opens up a world of possibilities for complex scripting and integrations. It even comes pre-packed with built-in skills for handling common document types like Excel, CSV, PDF, DOCX, and PowerPoint extraction.
Intelligent Memory: A game-changer for conversational AI, the new Memory feature allows agents to recall user preferences and conversational context across multiple sessions. Imagine an agent that genuinely remembers your role or preferences, eliminating repetitive inputs.
Dynamic Skills Creation: The new "Skills" concept is a powerful way to encapsulate agent capabilities. What's truly impressive is the ability to refine these skills through natural language prompting in the preview mode, with the agent automatically generating the necessary skill.md file. This democratizes complex agent programming.
Reimagined Workflows: Power Automate flows have evolved into "Workflows," offering sequenced actions, conditional branching, and loops. This not only provides a more structured way to build complex agent logic but also serves as the new, more organized home for triggering autonomous agents.
Enhanced User Experience & Safety: The new Preview canvas now includes a helpful latency readout, giving developers real-time insights into agent response times. Furthermore, safety and moderation features have been improved with a wider, more granular range of levels.
Effortless File Generation: The orchestrator's ability to generate downloadable HTML and Excel files directly from agent interactions, without requiring manual coding, is a testament to its advanced automation capabilities.
Flexible Knowledge Integration: While the direct Dataverse knowledge option is absent, the Dataverse MCP tool effectively fills the gap. The prominent "Public Websites" toggle ensures agents can access up-to-date information via Bing search, and the ability to upload unstructured PDFs as knowledge sources adds significant versatility.

Challenges (The Bad): Missing Pieces and Friction Points:
Despite its innovations, the Version 1 release of Copilot Studio presents some notable hurdles and missing functionalities that power users will undoubtedly feel.

The Demise of "Topics": Perhaps the most significant "bad" news is the complete removal of "Topics." These were the bedrock of structured conversational trees, enabling pre-programmed messages and questions. Their absence creates a void for precise conversational control.
Loss of "Solution-First" Building: The new "New Agent" button immediately drops you into the build workspace, removing the initial option to select a solution and schema name. This can disrupt established development workflows for those who prioritize a structured project setup.
Hidden & Relocated Features: The "Tools" section, once highly visible, is now less prominent. Environment selection has moved, and suggested prompts and settings are tucked deep within the settings menu, requiring more navigation to find.
Limited Evaluation Options: The new "Evaluate" mode, while promising, currently only supports quick question sets and general quality testing, lacking the diverse metrics available in the classic experience. Debugging is also largely confined to the live preview window, with no separate activity history tab.
Conversation Routing Limitations: The reliance on heavy natural language prompting for conversation routing, coupled with limited or broken Adaptive Card button selection, can make precise control challenging.
Specific Syntax for Skills: While powerful, the requirement for strictly lowercase/hyphen naming syntax for skills, and the absence of forward-slash shortcuts for linking assets, introduces minor friction points.
Missing Channel Integrations: Some familiar channel integrations, like SharePoint, are currently missing from the "Publish" dropdown.
No Inline Child Agents: The ability to create child agents that existed only within the context of a parent agent has been removed.

The Heavy Lifting Ahead:

Re-evaluating Conversational Design: For those heavily reliant on "Topics," the immediate "ugly" choices involve either reverting to the classic experience (and foregoing the new orchestrator's benefits) or the heavy lift of attempting to embed structured conversations directly into agent instructions and skills. There's a glimmer of hope that future "Workflows" might reintroduce similar node-based conversational control.
Advocating for Change: The most critical "ugly" task falls on power users: submitting formal feedback and Design Change Requests (DCRs) to Microsoft. The author explicitly states this is crucial to ensure that essential functionalities return before general adoption. Your voice is vital.
Adapting to New Paradigms: Users must embrace the new approach to skill creation—iteratively prompting the agent to refine capabilities and generate skill.md files. Similarly, understanding and leveraging the new "Workflows" feature is no longer optional but a fundamental part of building robust agents.
Rethinking Multi-Agent Architectures: With inline child agents gone, the "ugly" reality is a shift towards building standalone child agents and connecting them, or fully embracing "Skills" as the primary replacement for modularizing agent capabilities.

A Promising, Yet Evolving Platform:
The new Copilot Studio is a bold step forward, bringing powerful AI orchestration and intelligent features to the forefront. However, it's clearly a Version 1.0. While the "good" aspects promise an exciting future, the "bad" reveals areas of regression that demand attention. The "ugly" truth is that shaping this future requires users to roll up their sleeves, adapt to new paradigms, and actively provide feedback. By doing so, we can collectively help guide Copilot Studio into becoming the truly comprehensive and intuitive agent-building platform it aspires to be.

DEV Community: Bala Madhusoodhanan

Your Next Career Move May Already Be in Your Work: Discovering Career Evidence with Work IQ

Designing Intelligence: From Ad-Hoc Prompts to Enterprise AI Skills

Unshakeable - Ancient Wisdom for Modern Resilience

From Clicks to Documentation: Converting D365 Task Recordings into L4 Guides

Build Repeatable AI Workflows with SharePoint Skills

Less Doing, More Living

Enhancing AI Governance with the ai-governance-classifier Skill

Automating RAG Regression Tests with an AI-Driven Evaluator (AI Builder + Copilot Studio)

Prompt Engineering for Automated Evaluation: Making LLMs the Judge in AI Builder Solutions

Ask, Filter, Deliver: Interactive Work Item Exploration for Product Teams

Automating Your Weekly Prep with an AI-Powered M365 Briefing with WorkIQ

📥 Immediate Action — Inbox

📥 Action Required — Inbox

📥 Other — Inbox

📨 Immediate Action — Sent Items

🌐 External

🏢 Internal

📨 Action Required — Sent Items

🌐 External

🏢 Internal

📨 Other — Sent Items

💬 Teams: Unanswered Mentions

📝 Draft: Weekly Status Update for My Manager

📅 Upcoming Week — Meeting Preparation

Category A: I Organise — No Agenda Yet

Category B: I'm Mentioned / Have Prep Tasks

Category C: Other Relevant Meetings

🗓️ Next Week — Capacity & Focus Planning

✅ Consolidated Priority List — Week of [Date]

Transform Raw Data into Visual Insights in Copilot Studio with a Single Skill!

Navigating the New Copilot Studio: A "Good, Bad, and Nitty-Gritty" First Look