Then tomorrow you open a different git worktree for a parallel task. Or you clone the repo again into a sibling folder because that’s how your team works around branch isolation. Or you sit down at a different machine. And the assistant is a blank slate again. Everything you taught it yesterday is just... gone.

This isn’t a bug. It’s a direct consequence of a fact most of us don’t think about until it bites us: “the same repo” is not one thing. A sibling clone, a linked worktree, and a fresh checkout on another laptop all look identical to you — same files, same history, same branch names — but to most tooling, including your editor’s memory of past conversations, they are entirely separate, unrelated folders that happen to share a git history.

Once you accept that, a second realization follows: there isn’t one place to “remember” things. There are several, each with a genuinely different scope, a different loading behavior, and different rules about what belongs in it. Picking the wrong one either means the knowledge never reaches a new clone at all, or it gets duplicated somewhere it can quietly drift out of sync, or — worst case — it ends up permanently baked into your git history when it should never have been written down anywhere near version control.

This post is a field guide to that decision, built from actually working through it in one real repository.

Scope note: everything concrete in this post — the settings, the folder-scanning behavior, the auto-run task, the exact mechanism names — is specific to VS Code and GitHub Copilot Chat inside it. The three-axes framework generalizes to any coding agent; the specific knobs described below do not. Keep that distinction in mind as you read, and see the call-to-action at the end.

The three axes that actually matter

Every knowledge store below can be placed on three independent axes:

1. Portability — does this content travel to a new clone, a new worktree, a new machine, or is it stuck to the one folder you’re sitting in right now?

2. Ambient loading — does this content show up automatically in the agent’s context, or does someone (or something) have to go looking for it on purpose?

3. Sensitivity fit — is it safe for this content to live somewhere that’s tracked by git forever, or does it need to live somewhere that never becomes part of version history?

Almost every mistake in this space comes from conflating two of these axes — assuming that because something is portable, it must also be ambient, or that because something is committed, it must be safe. It isn’t. They’re independent, and you have to reason about all three separately for every piece of knowledge you want to keep.

The stores, one at a time

1. Session memory — the scratchpad

The shortest-lived tier: notes scoped to the current conversation only, cleared when it ends. Useful for in-progress task state you don’t want cluttering anything more permanent. Zero portability, by design — it’s not supposed to outlive the conversation.

2. Repo/workspace memory — the surprising one

This is the tier most people assume is “remembering the project.” It persists across conversations, which feels like durability. But it’s keyed to a workspace-storage identifier tied to the specific folder path you opened — not to the repository as a concept, and not even to its git remote.

The practical consequence, confirmed directly in this session: open a git worktree of the exact same repository, on the exact same machine, one directory over — and its memory starts completely empty. Not stale, not partial. Empty. The same is true of a second sibling clone, or a fresh git clone anywhere else. This tier’s real scope is “one folder, as opened by this tool, on this machine” — nothing about the word “repository” implies anything wider than that.

That makes this tier good for exactly one thing: a working index. Short pointers to where the real, durable version of something lives, plus anything genuinely too in-progress to be worth promoting yet. It’s a bad place for anything you actually want a new clone to inherit.

3. User (global) memory

One level up: notes that persist across every workspace this tool touches, not just one folder. This is closer to “portable,” but the portability is still bounded by the machine and the local tool installation — it doesn’t travel via git, and it doesn’t follow you to a different computer on its own.

4. Repo-committed instructions: from bespoke per-tool files to AGENTS.md

Now we leave the tool’s private state entirely and enter git. A root-level instructions file is just a file in your repository. That’s the whole trick and the whole value: it is exactly as portable as your repository. Every clone, every worktree, every fork, every collaborator gets it automatically, because getting it is identical to getting the code.

What’s actually interesting here is how this convention got to where it is. For a while, every coding-agent product invented its own bespoke filename for the same idea: .github/copilot-instructions.md for GitHub Copilot, CLAUDE.md for Claude, and so on, each vendor-specific, each requiring you to maintain a near-duplicate file if you wanted more than one tool to understand your project the same way. AGENTS.md is the industry noticing that pattern and converging on one shared answer instead: a single, vendor-neutral root file that an increasing number of coding-agent tools read natively, precisely so a project only has to state its rules once rather than once per tool. It’s worth treating as the default choice for new projects now, with tool-specific files reserved for genuinely tool-specific configuration that has no equivalent elsewhere.

This is also, as far as we could establish, the most tool-agnostic option on this list, full stop. Where a personal, client-specific setting might only mean something to one editor, a repo-root instructions file — especially the shared AGENTS.md shape — is a convention multiple coding-agent products already recognize. If a rule needs to reach every surface that might touch this project, human or automated, editor-based or CLI-based, this is where it has to live.

The tradeoff: everything in it loads into every session, every time, regardless of relevance. Fine for genuinely global rules (”here’s our stack,” “here’s our deployment model”). Wasteful if you start stuffing narrow, file-specific gotchas into it.

5. Scoped repo instructions (applyTo-matched files)

The refinement: instructions files that are still committed to git — still fully portable the same way — but tagged with a file-path pattern so they only attach to a session when you’re actually touching matching files. A rule about a date-picker bug only shows up while you’re editing that JavaScript file; a rule about log-ID discipline only shows up while you’re touching the log directories. Same portability as the root-level file, dramatically less noise.

The one thing this mechanism can’t do on its own is scope by repository identity — its matching is purely about file paths inside whatever workspace is currently open. If you need “only apply this when I’m specifically in Project X,” you need a different technique, which is exactly why the next tier needed an extra trick.

6. Personal, cross-project instructions (synced outside any repo)

This is the tier built specifically to answer: “how do I make my own knowledge follow me, across every project, on every machine I use — without it ever becoming part of any project’s git history?”

The mechanism in VS Code: a client-side setting that registers an entire folder as a source of instruction files. Point it at a folder inside a personally-synced cloud drive, and every file dropped into that folder is picked up automatically, in every workspace, the moment that client starts a session — with no per-repository setup at all, because the registration lives at the user’s tool profile, not inside any project.

Worth being explicit about one thing, since it’s easy to assume otherwise: there is no folder VS Code ships with for this, and no required name for it. The folder — wherever it lives, whatever it’s called — is something you create. The only real requirement is that it sits somewhere already synced across the devices you use, so the files themselves show up everywhere without any extra effort: OneDrive, iCloud Drive, Dropbox, or even a small private git repository you clone onto each machine all work equally well. The sync mechanism and the VS Code setting are two separate, complementary steps — the sync layer gets the files to every machine; the setting is what tells that one editor to actually go looking for them there.

Setting it up is a few minutes of work: create the folder anywhere convenient inside whichever synced location you already use, then point VS Code at it — either through the Settings UI (search for “instructions files locations”) or directly in your user settings.json:

"chat.instructionsFilesLocations": {
  "/absolute/path/to/your/synced/folder": true
}

That’s the entire one-time setup. What we’ll come back to later in this post — in “The tooling” section — is automatically verifying that wiring is actually intact on whatever machine you’re sitting at, rather than just hoping it is.

Two details make this tier work well in practice:

• Because the folder is scanned as a whole, you don’t register files individually — drop a new file in, and it’s live next session.

• Because file-path matching can’t express “only in this specific repository,” each file needs its own internal guard: a quick check for something unique to the target project (in our case, the presence of one specific committed file that only exists in this codebase) before applying anything. Get that guard wrong and personal notes meant for one project start leaking opinions into unrelated ones.

The scoping technique, concretely. The file-matching pattern this tier’s mechanism normally relies on can restrict which files an instruction attaches to, but it has no concept of which repository you’re in — a folder full of personal instructions gets offered up in every workspace, indiscriminately. The fix is to move the scoping decision out of configuration and into the instruction text itself, as a guard clause the agent is told to evaluate first, before doing anything else in that file:

Scope guard: only apply the content below if the current repository root contains .github/instructions/ace-log-ids.instructions.md — a file that only exists in this specific project’s checkout. If it’s absent, ignore everything below and behave normally.

Any sufficiently unique, already-committed fingerprint works — a distinctive file path, a particular config key, a marker nobody else’s repository would plausibly have. The guard is cheap to check, doesn’t require running any external command, and turns a blanket, everywhere-applies folder into something that behaves, in practice, as if it were scoped per-project — without the underlying mechanism needing to know anything about git remotes or repository identity at all. This is the piece that makes a single, shared personal folder safe to use across many unrelated projects at once.

This tier is also, importantly, where content that should never touch a project’s git history belongs — real hostnames, ports, and credentials that a developer needs available every session, but that must never be committed anywhere, ever, even for a moment. More on why that “even for a moment” qualifier matters below.

The honest caveat: this specific mechanism is a feature of one particular editor’s chat client. It is not confirmed to reach a command-line agent, an asynchronous cloud-hosted agent, or any other surface that might touch the same codebase. Repo-committed content is still the only thing guaranteed to reach every surface. Treat this tier as a powerful supplement for one editor, not a replacement for the git-portable tiers above.

7. A structured, searchable knowledge log

Different shape entirely: a directory of individually identified, git-committed entries — one per lesson or pattern, each with its own ID, searchable, cross-referenceable from other entries and from work-tracking documents. It has the same portability as any other committed file — every clone gets every entry — but it is deliberately not ambient. Nothing injects its contents into a session automatically. An entry only helps once something, human or agent, goes looking for it on purpose.

That makes it the right home for formal incident write-ups and patterns worth indexing for later search, and the wrong home for anything that needs to silently shape behavior without being asked. It’s a library, not a whisper in your ear.

8. Skills / playbooks

Not “knowledge” in the same sense as the tiers above — more like a committed recipe an agent can be told to follow for a recurring, multi-step job. Still just files in the repository, still fully portable the same way. Their special trick in this story: you can use one to encode the very discipline of managing all the other tiers, so the reasoning above doesn’t have to be rediscovered from scratch next time. That’s exactly what we ended up building — more on it below.

What we tried and ruled out (so you don’t have to)

Three approaches looked promising and turned out to be dead ends, each for an instructive reason.

A manual “seed” file living outside the repo. Works, technically — hand its contents to a fresh session and ask it to rebuild its own working notes from it. The problem is entirely human: it only helps if someone remembers to do it, every time, in every new clone. The moment a synced, auto-loading personal-instructions tier exists, this approach becomes strictly worse at the same job for zero benefit — so it was dropped in favor of that tier once it was clear both could achieve the same goal.

A git hook that fires on clone. This one doesn’t just have rough edges — it’s not really possible. Hook scripts live in a local, unversioned directory that is never transferred by git clone in the first place; there is no “post-clone” moment a repository’s own content can hook into. The closest workaround (pointing git at a versioned hooks folder) still requires a one-time setting on the destination machine before it does anything — the identical bootstrapping problem as syncing an editor setting across machines, just relocated. It doesn’t solve anything a synced setting doesn’t already solve more simply.

A git-committed snapshot of accumulated notes. This one is the subtlest trap, and the best illustration of why the three axes matter. Copying a folder of working notes into the repository and committing it absolutely achieves portability — every clone gets the exact files. But nothing makes an agent read them. A file sitting quietly in the tree, unreferenced by anything, is exactly as invisible to a fresh session as if it didn’t exist. Portable and ambient are not the same property, and this was the cleanest possible demonstration: full marks on one axis, zero on the other, and the result is still useless for the actual goal.

Sensitivity: the axis that bites hardest

Partway through this exercise, real connection details for a production server ended up briefly committed as part of an early snapshot. Nothing catastrophic — no credentials, just a hostname, a port, and a username — but it’s exactly the kind of detail that should never enter a git history, even for a moment, even in a private repository.

The fix illustrates a genuinely useful piece of git literacy: whether removing something like this is cheap or expensive depends entirely on where it sits in history, not on how you feel about it.

• If the offending commit is still the very tip of the branch, has no commits stacked on top of it, and nothing else already refers to its hash — fixing the file and re-committing in place (commit --amend, then a force-push of that one commit) is functionally equivalent to fixing a typo before anyone saw it. Cheap, fast, low blast-radius.

• If other work has already been built on top of it, or another clone has already fetched it, the calculus changes completely: now it’s a full history rewrite, which changes every descendant commit’s identity and forces every other clone to reset or re-clone. That’s a genuinely disruptive operation, not a routine cleanup step, and it deserves to be treated with the same caution as any other destructive, hard-to-reverse action.

The lesson generalizes past git: the real control is deciding in advance which tier sensitive content belongs in (the personal, never-committed tier, full stop) rather than relying on being able to clean it up after the fact.

The tooling: making the wiring itself verifiable

Knowing the personal, synced-instructions tier exists is only useful if you can trust it’s actually switched on for whatever machine you’re sitting at. That trust shouldn’t require inspecting internal application settings by hand every time you’re not sure, so three small pieces of tooling were built to make the whole chain checkable — and, where possible, automatic.

The loader/checker. A small, cross-platform script that goes straight to the source: it locates the editor’s own user-level settings file (the path differs across macOS, Windows, and Linux, and the script knows all three), reads the actual registration for the personal-instructions folder — tolerating the human-readable comments that setting file allows, which a naive strict-JSON parser would choke on — and confirms that folder genuinely contains this project’s files, not just some folder, any folder. It reports a clear pass or a clear, specific fix if anything in that chain is broken.

The task. That script is wired into the repository’s own task definitions with a “run automatically when this folder is opened” flag. This detail matters more than it looks: task definitions are ordinary version-controlled files, so — unlike a git hook — this check travels to every clone and every worktree automatically, with no pre-existing setup required on the destination machine at all. Open the folder, get the answer, with one small one-time permission prompt the first time.

The actual snippet is short enough to reproduce in full — it lives in .vscode/tasks.json, as one more entry in that file’s top-level "tasks" array, alongside whatever other tasks a project already defines:

{
  "label": "Check: Personal Instructions Wiring",
  "type": "shell",
  "command": "python3",
  "args": ["${workspaceFolder}/scripts/check-personal-instructions.py"],
  "windows": {
    "command": "python",
    "args": ["${workspaceFolder}/scripts/check-personal-instructions.py"]
  },
  "runOptions": { "runOn": "folderOpen" },
  "presentation": { "reveal": "always", "panel": "dedicated", "focus": false }
}

Two details worth calling out: the windows block overrides only the interpreter command, since Windows Python installs commonly register as python rather than python3 on PATH; and runOptions.runOn: "folderOpen" is the one flag doing all the automatic-execution work — delete just that block and the identical task still works fine, just as something you trigger manually from the command palette instead.

The skill. All of the reasoning above — which tier for which kind of knowledge, how to create a new personal-instructions file correctly, how to think about the sensitivity axis, how to avoid the same fact living in two places and quietly drifting — was written down as a committed playbook the agent itself can be pointed back to. It’s a small recursive trick: use one of the portable-knowledge mechanisms to preserve the knowledge of how to use all the portable-knowledge mechanisms, so the next person (or the next session) doesn’t have to re-derive it from first principles.

Where does settings sync fit in?

One easy misconception: since the personal-instructions tier is registered by a setting, surely that setting needs to be re-created for every clone and worktree?

It doesn’t — and the reason is worth internalizing, because it’s the same shape as the memory-tool problem from the opposite direction. The registration lives at the level of the editor’s user profile, not at the level of any individual folder. Once it’s set, it already applies to literally every folder that profile ever opens, on that machine — including clones and worktrees that don’t exist yet. There is nothing to replicate per-checkout, because it was never attached to a checkout in the first place.

The one place replication genuinely matters is a different machine — a second laptop, a rebuilt environment, a colleague’s setup. That’s precisely what an editor’s built-in settings-sync feature exists to solve: turn it on once, signed into the same account, and that same registration follows you to anywhere else you sign in. The one wrinkle worth knowing: if the registered path is written in one operating system’s path syntax, syncing the raw setting to a different operating system carries over the text but not its meaning — you’ll still need to point it at wherever your synced folder actually lands on that platform. Sync solves replication; it doesn’t solve translation.

The cheat sheet

StoreTravels to...Shows up automatically?Lives in git?Best forSession memoryNowhere (this conversation only)Yes, this conversationNoIn-progress scratch stateRepo/workspace memoryNowhere — one folder path, one machineYes, in that folderNoA working index; pointers to the real sourceUser (global) memoryEvery workspace, one machineYesNoPersonal habits/preferences, this machineRoot instructions file (copilot-instructions.md / AGENTS.md)Every clone/fork/worktreeYes, alwaysYesGlobal, always-relevant project rules; the most tool-agnostic optionScoped instructions (applyTo)Every clone/fork/worktreeYes, when matching files are touchedYesNarrow, file-specific standing rulesPersonal synced instructionsEvery workspace, this editor, any machine you sync toYes, gated by a manual identity checkNoPersonal cross-project knowledge; anything too sensitive to commitStructured knowledge logEvery clone/fork/worktreeNo — search onlyYesFormal, indexed incident/pattern recordsSkills/playbooksEvery clone/fork/worktreeNo — invoked on requestYesMulti-step procedures worth never re-deriving from scratch

The takeaway

There’s no single “memory” to fix. There are (at least) eight places knowledge can live, three independent questions to ask about each piece of it — does it travel, does it show up unasked, is it safe to commit — and the entire discipline is just answering those three questions honestly before you decide where something goes. Do that consistently, and a brand-new clone, a brand-new worktree, or a brand-new machine stops being a blank slate and starts being exactly as capable as the one you were already working in.

The ask for you

As flagged up top, everything specific in this post — the settings, the folder-scanning behavior, the auto-run task — is VS Code and GitHub Copilot Chat territory. The three-axes framework (does it travel, does it show up unasked, is it safe to commit) should hold regardless of which coding agent you use, but the actual knobs almost certainly look different in every other agent harness — the surrounding tool/runtime that wires a model up with context, tools, and memory, as distinct from the model itself. GitHub Copilot CLI, Claude Code, and every other harness out there each make their own choices about what’s ambient, what’s portable, and what’s user-scoped versus project-scoped, and those choices are worth knowing before you assume a technique from one transfers cleanly to another.

If you’ve solved this problem in a different harness — a CLI tool, a different editor, a cloud-hosted agent — I’d genuinely like to hear how. What’s the equivalent of a fingerprint-guarded personal folder in your setup? Is there an AGENTS.md-style convention your harness treats specially? How do you keep sensitive details out of a repository while still making them available every session? Share what’s worked (and what hasn’t) — this space is moving fast enough that the best techniques are still being worked out in public, one repository at a time.

Resources and discussion

You can find the samples for this article in my Samples repo on GitHub.

You can discover more and join the conversation on Substack, LinkedIn, or GitHub.

The approach was not fancy. But the result was so good that, over time, I’ll iterate and improve the prompt

The problem: Template and formatting hell

I know a lot of you already know exactly what I’m about to say in this section. If by reading the headline alone, you already fully understand and relate to the problem space, skip to the next section.

PowerPoint’s most powerful features--masters, layouts, themes, and color palettes--are also the leading cause of frustration for anyone who works in PowerPoint, particularly people who assemble presentations from slides that have been created using other decks (which have their own collections of masters, layouts, themes...).

As you assemble a deck from multiple sources, you have a Sophie’s Choice to make: “Paste and use destination theme” which blows up the formatting of the slides you’re bringing in to your deck; or “Paste and keep source formatting”, which ends up making your deck look exactly what it is: a Frankensteined patchwork of disconnected slides. No matter which choice you make, if you want to deliver a coherent and consistently designed presentation, you’re likely going to be spending a lot of time doing manual formatting to reconcile differences.

My customer’s particularly hellish hell

The impetus for this solution was a customer who creates online learning for medical professionals using presentations from professional conferences. So, these are decks created by doctors. Let’s just say...

I’m a doctor, Jim! Not a PowerPoint expert!

Yeah: the source decks were beyond tragic. To date, it has been a mammoth, lengthy process to manually reformat each deck into something that looks as professional as the content; and that aligns with the high design standards for all courses the online learning portal.

How we approached building the solution

We spent approximately two hours building the first version of the solution using Copilot in PowerPoint. At the Microsoft 365 Community Conference, I was lucky enough to be recruited to demo Copilot in PowerPoint for Jeff Teper’s keynote and, from doing so, had a sense that the technology might finally be up to the task.

First step was manual: We opened one of the ultra-messy “doctor decks” and added a slide master that reflected the desired look-and-feel with layouts that reflected common layouts used in doctor decks. This represented our target formatting.

The end-goal here was to convert a sloppy slide into a sizzing slide, with as much automation as possible. But, particularly during iterative development of our automation, we wanted to preserve the original for reference, so we could compare the original to the target slide.

So, the first prompt we tried asked copilot to look at a single slide, duplicate it (to preserve the original) and, on the copy, to visually examine the source slide and identify the target layout that best reflected the intent of the author. This is important because, often, people will create slides in wonky workflows, for example starting with a blank slide and dropping text boxes for the slide title and bullet points, instead of using a layout with title and content placeholders. By considering the intent of the slide, rather than the specific way it was created, we can remove that variance.

The prompt also instruced to apply that layout and reset the slide. PowerPoint’s “reset” action removes directly applied formatting including positioning, sizing, and font formats. It effectively snaps the slide to the formatting of the layout.

We executed the prompt on several slides and WOW! we were very impressed by the accuracy of Copilot’s choices.

The next step was to try to reflect the author’s intent regarding text placement. Far too many PowerPoint creators will create text with ‘extra lines’ between paragraphs (”Hit twice”) to create whitespace between points. For our doctors’ slides, they might put a citation at the bottom of the slide by pressing enter 10+ times until the text was at the bottom (ugh!).

Our slide master had proper line spacing (using the Line Spacing command; adding space before and/or after). We prompted to examine text spacing and the intent of the author. If the whitespace was “one line”, remove any extra line breaks. If the intent seemed to be to position the text somewhere specific, like the bottom of the slide, then position it correctly, accordingly.

Next was the text formatting itself: font size, typeface, color, emphasis (bold, italic, underline, highlight). And OMG these doctors’ slides used every combination under the sun, sometimes on a single slide. The “reset formatting” already removed all formatting, resetting it to the fonts in the layout and theme. Now we had to reapply formatting thoughtfully, again based on the intent of the author.

We landed on this as our first approach:

• For font size, if the source slide had text in a significantly different size from other text at the same outline level, reflect that in the target under the assumption it is intentional.

• If an entire paragraph is formatted uniquely, do not reapply the formatting. Keep the paragraph aligned to the layout and theme. This resolved variances where, for example, a slide might have a patient story in itialics that wasn’t the standard for the online course.

• But if text within a paragraph was bold, italic, or underline, we reapplied the formatting to preserve it.

• If text was colorized, either a font color or a hilight color, we standardized it to a single font color.

Next was images. The target design had a slide background that was not pure white. That means that any image of a screenshot or a journal article (anything with a white background) will create a hard visual edge against the background. So, we added drop shadows to all images.

Finally, citations, which there are a lot of in this customer’s source decks. The customer does not want full citations visible on the slides during the course but rather references on slides with citations centralized to an appendix slide. Problem: every author uses a different format, placement, etc. Individual authors even applied different formats for citations on different slides. So, we visually look for anything that is a citation and move it off the screen. The customer has since updated the skill to create an appendix with each citation and references.

With these instructions, so far, we were already well on our way to saving our customer hours of work per deck.

ProTip: Agent logging and learning

As we tested each improved prompt, we could see in Copilot’s response how it thought about the prompt, how it applied the instructions, and how it evaluated the results. We fed the learning into each subsequent revision to the prompt. But as we readied ourselves for Copilot to iterate over multiple slides--even an entire deck--we would lose that learning.

We added to our prompt an instruction that Copilot add a text box, off to the side of the slide (outside the visible area), and log what it did and why: which layout it picked, which formatting it reset, and which formatting it reappplied. That way, when the agent completed its work, and we were comparing the original slides to the target slides, if something wasn’t quite right we could learn why, improve the prompt accordingly, and retry the prompt on the same source slide.

Through this, the system became, in a way, self-aware and self-improving with a little help from Copilot’s human companions.

What’s next

This will be an iterative process of learning from the agent’s output, finding the next set of gaps and variances, improving the prompt, and trying again. With this particular scenario, it’s hard to imagine an agent making 100% perfect choices every time because far too many people (doctors, not PowerPoint experts) are involved. But we can prioritize where to invest in improvements and get closer each run.

At this point, we have a massive prompt that works quite well—nay, surprisingly well. There is not yet a good way to turn this into a replicable automation (e.g. a “skill” for Copilot in PowerPoint). Any ideas??

One of the areas for rich improvement will be color choice for text and graphics. PowerPoint non-experts don’t realize that accent colors are dynamic, based on the theme. Accent Color 3 might be red in your current master, but blue in the new master. All text you formatted in red using Accent Color 3 will now be blue after applying the new master. That’s probably the right choice for most body text. But if you’ve created a stop sign shape using an octagon shape with red fill (Accent color 3) and text “Stop” that is white (Text 1), you could end up with a blue stop sign with black text in your new formatting. We will build logic that evaluates whether the intent of the author was a specific color, in which case the correct action would be to apply red as a proper color, not a theme color.

And we will tackle modern formatting, including rounded corners. PowerPoint’s UX doesn’t expose rounded corner radius and, generally, designers won’t want the same radius applied to a box the size of the slide itself and for a box that’s a fraction of the slide’s area. But agents can access the setting!

Automating intelligent visual element usage. Think of how many marketing slides have a date statement like “Coming “. Now think about how many different ways that information is visually coveyed in a single deck. Copilot can recognize date statements and treat them all the same way within a deck.

What ideas do you have? Share them in the replies!

Copy the solution for your work

I’m sharing the prompt, in its entirety, below. This was the result of only two hours of learning; and there is much more room for improvement.

The “deal” is if you copy it, you contribute to it.

Prerequisite

You must have a slide master with layouts that approximate the types of layouts source slides might have. The more aligned your layouts are to the source material, the more accurate that early step of identifying the best layout will be, and the less “tweaking” you’ll have to do later.

The prompt below assumes you have already added the target master to the source deck. There are several ways to do this. One is to copy any slide from the target deck, paste into the source deck and choose “Keep Source Formatting”. Rename the master “TARGET” (or change the reference in the prompt). You could also work on the prompt to load from the target master template directly, for example by providing a link to the .potx or .pptx.

The most important thing for this process: layouts with placeholders and relative font sizes. Everything else can be easily modified later. I will loop back here and share my favorite masters and layouts with you.

The prompt

The prompt (v1) is below. Contribute your ideas in the comments or, if you have Git skills, through my powerpoint-tools repo.

We are working together to improve the design and layout of this presentation and to standardize formatting using the slide master called "TARGET". 

We'll work one slide at a time. Preserve a copy of the original slide, duplicate it, and work on the duplicated slide.

Visually examine the slide and determine which layout from the "TARGET" master best suits this slide. Apply that layout and reset the slide. 

After reset, we will apply direct formatting using visual comparison of the original and newly reset slide. The goal of this step is to create a visual hierarchy on the new slide that reflects the intent of the original.

Use these rules:

- If text on the source slide has italics, underline or bold, and it is a subset of the text in the paragraph or item, maintain the formatting. If it is the entire paragraph, do not.

- If the source slide has text with a noticeably smaller font size, that is usually intentional and we should apply a smaller font size after resetting the slide.  

- If the source slide has text that is ‘called out’ visually, for example with a highlight or font color, apply the following direct formatting to the text: font color is dark red.

- If a slide has white space between paragraphs that looks close to a line (or less) worth of space, do not add a blank paragraph. Layout line spacing formats will take care of that.

- If a slide has text with significant white space between items--something that visually looks like "more than one line of space"--we should try to understand the intent and replicate it on the new slide. Is the intent to create more visual break between peer points; or is it to align the text to a specific position on the slide (like the bottom)

- Any image placeholder should be formatted with a drop shadow and 8 pixel rounded corners.

If a slide has something that appears to be a citation, please do the following:
- Create a text placeholder just off the BOTTOM of the slide, OUTSIDE the slide itself
- The font should be the (body) font at 10pt, font color black 
- Move the citation text into that placeholder, preserving bold, italic and underline but removing any original font face or size.

If the source slide had text or graphic elements, work to ensure the new slide remains true to the intent of the positioning of those elements. 

After you have finished applying direct formatting:
- Create a text placeholder just outside the slide on the right.
- Font should be (body) font at 10pt, font color black
- Enter the first line of text: “Copilot Formatting”
- Then enter text explaining your thinking about the slide: Which master layout you picked and why; what direct formatting you ignored because the slide layout already accomplished the intent of the original slide; and what direct formatting you reapplied and why.

Landing in early 2025 for all Microsoft 365 commercial customers (leader & audience features for Viva customers).

Two years after the general availability of storyline in Viva Engage, we've seen tremendous adoption from both leaders and communicators as well as information workers and FLWs. Bringing storyline into Teams as a native feature will unlock storyline's superpowers for communication and connection to the hundreds of millions of Teams customers.

Importantly, storyline in Teams is the same feature as Engage. What you share on your storyline from either, shows up in both. This is an integration, not a replacement or a duplicate feature.

We also signaled in our blog post that community integration and much more is coming. Importantly, Engage is not going away--it will remain offering web, desktop, and mobile apps, and store apps ("metaOS") for Outlook and Teams. But we're bringing the products closer together in Teams, so that Teams customers can leverage the superpowers of Engage for communicating, engaging employees, and sharing knowledge at scale. This is nothing but a small step for storyline toward a giant leap for Engage and Teams customers. We've got so much coming in 2025, I'm giddy! Can't wait to share the new and the journey with you!

Read the announcement at https://techcommunity.microsoft.com/blog/viva_engage_blog/what%E2%80%99s-new-in-viva-engage-%E2%80%93-ignite-edition/4299865

Viva Engage brings people together across the organization to connect with leaders and coworkers, find answers to questions, share their unique story, and find belonging at work. Today, we are rolling out new features for Microsoft Viva customers that empower leaders and employees to connect, communicate, and engage more effectively, and enable everyone to find answers and experts across the organization.

This article will provide an overview of seven new features:

1. Leaders and audiences

2. Personal and audience analytics for leaders

3. Storyline announcements and posts for leaders

4. Leadership corner

5. Ask-me-anything events (AMAs)

6. Social campaigns

7. Answers in Viva

Future articles will go into more depth about individual features, best practices and learnings from customers.

If you’re not familiar with Viva Engage, would like to explore the features available to Microsoft 365 customers at no additional cost, or want to know more about the plans we announced today to rebrand remaining Yammer experiences to Viva Engage, you can learn more about Viva Engage in Microsoft 365.

ENGAGING LEADERS AND EMPLOYEES

Viva Engage unlocks superpowers for leaders and employees to engage more effectively.

1. Leaders and audiences

The first, foundational step is to define leaders and their audiences. As a leader, your audience reflects the employees that will see your posts and announcements. And you will get rich analytics into your audience’s engagement and sentiment (more on that, later).

From the new Viva Engage admin center, you can identify a leader and configure their audience.

Audiences are based on Azure AD groups and users. Most customers already have distribution groups they use to send email communications. Those same groups can now be used to define audiences in Viva Engage.

A leader can optionally be given an “entire organization” audience, which allows the leader to reach every user in the organization.

FAQ: Leaders and audiences

• What types of groups can be used for audiences? Today, you can add security or distribution groups to a leader’s audience. Soon, you will be able to use a Microsoft 365 group as the leader’s audience, and we will add support for dynamic groups.

• Are audiences kept up-to-date automatically? Changes to group memberships automatically update the audience within 24 hours.

• Who can add leaders? Viva Engage admins and corporate communicators can add leaders.

• Who can define audiences? Viva Engage admins and corporate communicators can define audiences for any leader. The leader and their delegate managers can define the audience for that leader.

• What else do I need to know? When you define a custom audience by adding one or more groups or users, Viva Engage creates a security group in Azure AD, into which members are nested. Do not alter that group or its membership directly—use the Manage Audience experience to configure the audience.

2. Personal and audience analytics for leaders

Analytics empower leaders to know where they can engage with greatest impact.

Viva Engage introduces rich, actionable analytics including:

• Personal analytics. Understand the reach and engagement of your posts and activity.

• Audience analytics and sentiment. Aggregated, privacy-protected insights surface sentiment trends and themes of conversations across Viva Engage. Sentiment analysis uses Azure Cognitive Services to understand what’s being talked about in public conversations. Along with views of top discussions and trending content, and of adoption and activity in your audience, you can identify opportunities to engage effectively.

In addition, leaders and communicators will benefit from conversation insights, campaign analytics, and answers analytics, detailed later.

3. Storyline announcements and posts for leaders

Viva Engage empowers leaders to communicate effectively and reach and engage employees in the apps they use every day. Posts and announcements can be created by leaders or their delegates, and will appear across Microsoft Viva and Microsoft 365:

• Email (inbox), Teams (activity), and the inbox in Viva Engage and Yammer

• Viva Engage: the home feed, storylines feed and leadership corner

• Mobile notifications: iOS and Android

• Viva Connections: the company feed

• SharePoint intranets: the company feed and Yammer web parts

• Custom applications: Yammer embed

Announcements enable you to share need-to-know information with employees. From your storyline, you can create announcements that are sent from you to your audience across Outlook, Teams, Yammer and Viva Engage. Announcements can include video and photos and support reactions and comments to foster two-way dialogue. Conversation insights provide analytics to help you measure and improve reach and engagement.

If you want to share less critical updates, thoughts or vision with your audience, you can share as a storyline post. A post will not interrupt your audience with a dedicated email or notification. Instead, it will show up in feeds so your audience will see your post over time. If someone misses your post, they’ll likely see it in the storylines update—a weekly digest sent in email and Teams. This digest rolls up the most relevant content from your leaders and people you follow.

Storyline announcements and posts are visible on your storyline, and can be recommended to people outside your audience, extending the reach and impact of your communications. People who find your content valuable can follow you and choose to receive notifications when you share new content.

Viva Engage uniquely equips leaders and communicators with a range of options for reaching and engaging your audience—from critical updates that need to reach people immediately wherever they work, to less critical information that can be consumed more ambiently, on people’s own time. And Viva Engage uniquely gives leaders and communicators multi-channel reach and analytics. Together, these differentiators enable you to modernize your communications and engagement strategy—a topic we’ll definitely return to in this Substack.

4. Leadership corner

Leadership corner brings together leadership experiences across Viva Engage, empowering leaders and employees to connect and engage directly and effectively.

Leadership corner is an employee’s personalized hub, aggregating content and experiences related to your leaders based on the audiences you're in and the leaders you choose to follow.

You’ll see leaders’ posts and announcements across storylines and communities, so you can catch up with what’s top-of-mind. And you can engage in two-way dialogue with leaders, share questions and ideas in Ask-Me-Anything (AMA) events, and participate in social campaigns to drive business initiatives.

5. Ask-me-anything events (AMAs)

Ask-me-anything events (AMAs) empower employees to share questions, concerns and ideas, and for leaders to listen to, learn from, and create clarity for employees.

An AMA is an asynchronous (not “live”), chat-based question-and-answer experience. AMAs are moderated, so organizers can determine which questions are publicly visible. Participants can upvote questions to help organizers prioritize. Participants and organizers can comment and answer, and the best answer can be flagged to showcase and preserve knowledge.

Optionally, an AMA can allow anonymous submission to create a psychologically safe space for people to share their thoughts and perspectives.

AMAs are asynchronous (not “live”) and therefore complement the Q&A capabilities of Teams meetings, which are also powered by Viva Engage. If you’re going to get people together, at the same time, Q&A can be a powerful addition to any Teams meeting. AMAs allow you to schedule a Q&A event over a period of hours or days to be inclusive of people’s schedules and time zones.

Any employee can create an AMA event from their storyline. AMAs created by leaders will appear in leadership corner for people in their audience.

6. Social campaigns

Social campaigns spark employee participation in initiatives that support business goals and objectives including diversity initiatives, cultural moments, shared learning and ideation.

Campaigns are centered around a hashtag. Any employee can participate by sharing a post or question with the campaign hashtag.

Each campaign features a rich landing page with a cover photo, a visual goal tracker, campaign sponsors, and contributors. The campaign feed aggregates conversations across storylines and communities. Campaign owners can measure reach and engagement with analytics.

Campaign analytics help you understand the reach, engagement, and contribution profile of your social campaigns. Identify and praise top contributors and summarize campaign impact.

SHARE KNOWLEDGE, ANSWERS & IDEAS

Viva Engage empowers people to share best practices, solicit feedback, and innovate together in communities. Now, we’re doing even more to unlock the power of collective knowledge, so you can crowdsource answers from experts across the organization.

7. Answers in Viva

Answers in Viva enables people to ask questions and find answers quickly and effectively by leveraging the combined superpowers of social Q&A, AI, and experts.

Begin by asking a question. AI will recommend previous questions that have answers or, if none meets your needs, AI will route your question automatically to an expert on the topic. People active in the topic are notified that there is a new question they may be able to help with.

You discover questions they you can help out with in the personalized Questions for You feed. Answers can be upvoted and marked “best answer”. And, of course, the answer can be recommended the next time a similar question is asked.

Topics are one of the foundational superpowers of Answers in Viva. Questions are tagged with one or more topics, and people can view and follow interesting topics. Viva Engage topics are powered by Viva Topics. And while it is not necessary to fully deploy Viva Topics experiences to support Answers, customers will benefit from Viva Topics integrations with Answers, including topic pages that provide views of a topic’s resources and experts.

When you answer a question, you can earn badges. And answers analytics enable you to measure the impact you’ve driven by asking and answering questions. You can identify the most helpful questions you’ve asked, and the most valuable answers you’ve provided.

Admins can use global answers analytics to evaluate the impact of Answers in Viva across the organization. Identify popular topics, active experts, helpful questions and answers, and questions that need attention.

GETTING THE NEW FEATURES

The features described here are rolling out, starting today, and will arrive in customers’ tenants over the coming few weeks.

Licensing

Administrators will see a new Viva Engage admin center where can assign roles, including the new corporate communicator role, and configure features. Learn more about these new admin capabilities here.

These following features will be available to customers who have Microsoft Viva suite subscriptions:

• Leaders and audiences

• Personal and audience analytics for leaders

• Storyline announcements and posts for leaders

• Leadership corner

• Ask-me-anything events (AMAs)

• Social campaigns

Answers in Viva will be available to Microsoft Viva suite customers as well as Microsoft Viva Topics customers. Stay tuned for more options to try these new features.

Requirements

Many of these features require your Viva Engage/Yammer network to be in native mode and we will soon require all networks to be upgraded to native mode to support full compatibility with Azure AD and Microsoft 365. In addition, Answers in Viva requires that your Yammer topics are migrated to Viva Topics.

Resources

You can learn more about the features described in this article from these resources:

• DOCUMENTATION: Viva Engage Help & Learning

• ADOPTION RESOURCES: Viva Engage Adoption Resources

• BLOGS

  • Yammer is evolving to Microsoft Viva Engage with new experiences rolling out today

  • New Leadership, Analytics, and Knowledge Experiences for Viva Engage are now rolling out

  • Yammer is evolving to Viva Engage (rebranding announcement)

Join us February 23rd for a Viva Engage AMA

We’re hosting our own customer-facing AMA to answer your questions about Viva Engage. To learn more about the changes announced today, join me February 23rd for the Viva Engage AMA with the product leaders from the Viva Engage team.

Join us at the Microsoft 365 Conference and
European Collaboration Summit

I’ll be joined by members or our product teams to share the latest innovations with you, to dive deep into our technologies, and to answer your questions at two events this spring:

• The Microsoft 365 Conference: May 2-4, Las Vegas

• The European Collaboration Summit: May 22-24, Düsseldorf

If you can join us in person, please do!!

A PERSONAL NOTE

Today is a milestone for me, my team, and the entire Viva Engage organization. It was exactly 368 days ago that we presented our vision to our senior leadership team for how we could empower tens of millions of Yammer customers to deliver rich employee experiences with what would become Viva Engage; and enable leaders, communicators, and employees to communicate and share knowledge more effectively as part of Microsoft Viva.

Our teams worked tirelessly across product management, research, design and engineering to build features that you, our customers, told us you needed. We spent hundreds of hours speaking with leaders and communications professionals, performing user research, and listening through every channel possible.

Today it gets real. We are excited to share our work with you, and to learn what we got right, and what we need to improve. We are really excited to learn what you need next. Because we’re just beginning. Our product and engineering teams look forward to building the future of this product with you.

And a huge note of thanks to Murali Sitaram, my manager Venkat Ayyadevara, and our Viva Engage leadership team for taking a “bet” on me to cross the chasm and become a leader on this exciting journey. To all my mentors, supporters and friends, my heartfelt gratitude. I look forward to your feedback and ideas! And to sharing some well-deserved adult beverages to celebrate.

Wrapping up

Hopefully this gives you enough to understand and explain the new Viva Engage features for leaders, communicators and knowledge sharing to your organization and end users. I plan to share more perspectives and details in future articles. And to share learnings about how our customers are using these capabilities to improve communication, engagement, and connectedness.

What, exactly, do you want to hear more about? What questions can I answer for you? Let me know, here! And if this was valuable, please share it forward, and subscribe!

Share

Subscribe now

Viva Engage brings people together across the organization to connect with leaders and coworkers, find answers to questions, share their unique story, and find belonging at work. Today, we announced plans to unify our experiences under the Viva Engage banner by renaming our remaining Yammer applications and integrations.

This article will (re-)introduce Viva Engage and the capabilities and scenarios that are available to Microsoft 365 customers at no additional cost. You can learn more about new features for Microsoft Viva customers that we released today.

Viva Engage in Microsoft 365

Remote and hybrid work have made building and maintaining connections across working groups and business silos extremely challenging. In our Work Trends Index research, 43% of leaders identified building relationships at work as the number one challenge of hybrid work. Employees hired since the beginning of the pandemic are less likely to feel included (64%), and report weaker relationships with their team (51%)

Viva Engage is the application in Microsoft 365 designed to address these challenges by connecting people across the organization to enable community building, knowledge sharing, employee engagement and communications at scale.

For those unfamiliar with Viva Engage (and Yammer) in Microsoft 365, you can:

CONNECT WITH PEOPLE AND CONVERSATIONS: Viva Engage lets you tap into the heartbeat of your organization, with a Home feed personalized by AI to surface relevant conversations and connections from across your organization.

BUILD COMMUNITY: Communities connect people across working groups and business silos to foster inclusion and belonging, to support business initiatives that span the organization, and to enable communications and engagement at scale. Communities support myriad scenarios including:

• diversity and allyship

• employee interests and activities

• onboarding and professional development

• knowledge sharing and Q&A

• shared services

• business and cultural initiatives

HOST COMPANY-WIDE VIRTUAL EVENTS: Leaders, communicators, and employees can come together for company-wide live events featuring live and on-demand video, open discussion and Q&A. Share vision, align people and spark engagement.

SHARE FROM YOUR STORYLINE: Storyline enables leaders to share thoughts & vision with their own voice. And everyone has a place to share updates and knowledge, celebrate milestones and showcase work. Share with rich posts, videos and photos. Learn more about storyline in Viva Engage.

The core capabilities of these features—the feed, communities, events, and storylines—are available to most Microsoft 365 commercial customers at no additional cost. They’re available in Viva Engage and Yammer apps, and are integrated into Teams, Outlook, SharePoint and Microsoft Viva. And they’re built on the foundation of Microsoft 365, which delivers enterprise-grade security, privacy, compliance and manageability.

Rebranding Yammer to Viva Engage

Customers have made it clear that the scenarios Yammer delivers—community building, knowledge sharing, leadership engagement and employee communications—are critical to employee experience. We’re thrilled to bring Yammer’s superpowers to Microsoft Viva, our employee experience platform.

Last year, we introduced the Viva Engage app in Microsoft Teams—an evolution of the Yammer-powered Communities app. The Viva Engage app can be added to Teams by any user or deployed to the organization from the Teams admin center.

This year, we will rename and rebrand remaining Yammer experiences—our mobile and Outlook apps this spring (target: March) and our web application later this year. Learn more about our journey to rebrand Yammer to Viva Engage.

Hopefully this gives you enough to understand and explain Viva Engage to your organization and end users. I plan to share more perspectives on how to do so, in future articles. And to share learnings about how our customers are using these capabilities to improve communication, engagement, and connectedness.

What, exactly, do you want to hear more about? What questions can I answer for you? Let me know, here! And if this was valuable, please share it forward, and subscribe!

Share

Subscribe now

Today a customer asked, as many often do, how to understand storyline and stories (or should we say “storylines, posts and stories”?) in relationship to LinkedIn, Facebook, Insta, TikTok and other consumer media. If you’re not already familiar with the fundamentals of storylines, posts and stories, read my fundamentals article first.

Explaining storyline with social media comparisons

I often give customers a shorthand description of storyline as LinkedIn inside your organization”. What you share reaches your followers and coworkers across your company. You can share and discuss internal activity that would not be appropriate to share on public platforms, and you can build relationships that foster connectedness, professional development, and career advancement.

A more detailed explanation relies on one’s understanding and history with sharing and self-expression in consumer social media. Concepts of storyline, posts, and stories exist in various forms across a number of social platforms. Let me start with several snackable comparisons to social media constructs:

• Same: Your storyline is conceptually equivalent to your LinkedIn activity feed or your Facebook timeline, your “Insta” or your “TikToks”. It’s a place where you share stuff.

• Same: You share with stories and posts. Stories are media-centric posts—short videos or photos, very similar to stories, reels, and TikToks.

• Different: Some social platforms limit you to one or two formats for sharing: you can’t share posts on Insta or TikTok, and you can’t share photos on TikTok. On Yammer and Viva Engage, a bit more like Facebook, you can share posts and stories, and stories can be a short video (up to 3 minutes in public preview) or a photo.

• Different: This is a tool for sharing and self-expression in the workplace. Thus, the next section of this article…

Business and technical differences

The types of content and conversations shared on storylines in the workplace can be quite different.

There is no one “standard” for sharing posts and media across consumer social platforms, so I’ll leave you to compare to your platforms of choice, but these are relatively unique business and technical considerations for storylines, posts and stories in Viva Engage and Yammer:

Storyline is designed to provide a frictionless way to connect people, knowledge & expertise, experience and perspectives across an organization through serendipitous discovery of content & coworkers; to foster connectedness; and to build relationships that support productivity, innovation, professional development, and career advancement.

Your storyline is the expression of your persona at work. It’s where you can share updates, knowledge & perspectives, and express yourself in the context of your workplace.

• The culture and policies of your organization should shape what you choose to share and showcase.

Therefor what people share on storyline tends toward professional and work-oriented updates—more than you would see on most consumer social platforms. However, we see a lot of sharing of people sharing interests, passions and activities.

• Customers report they feel excited and fulfilled when they learn more about their coworkers. Storyline is proving it can be a powerful tool for helping people connect as human beings at work. Connectedness helps people find belonging, appreciate diversity, and increase empathy. We anticipate that, over time, we will be able to provide data that links these personal connections to increases in productivity, innovation, and retention—concepts that are already well supported by research into related solutions for engagement and wellbeing.

• In a future article, I’ll share a list of specific ideas of what people can share on their storyline.

Anyone in the organization can visit your storyline and follow you. And when you follow someone, their posts and stories will be prioritized in your feeds and carousels. You can also receive notifications when they post.

• Notifications tip: you can manage notifications you receive from one person from their storyline. You can manage notifications you receive from everyone you follow from your own storyline—click Following. And soon you’ll be able to manage notifications you receive from the notifications themselves.

Content you share is visible to everyone in your organization. Anyone can visit to learn more about you and will see your posts and stories.

• While your followers will see your content higher in their feeds, your posts and stories can be suggested to anyone based on numerous signals including who follows you, who you follow, and who engages with your content.

• There is not a way to “restrict” who can see your storyline or content.

Content does not disappear from your storyline. When you make the effort to share an update, experience, or perspective, it stays on your storyline until (if and when) you choose to delete it.

• Our goal is not to drive people to consume content every day—it’s to capture and share knowledge and connect people. Of course, posts and stories will eventually disappear from feeds and carousels in “discovery” experiences like the Home feed as relevance decreases over time and with less engagement. Stories are removed from the discovery carousels after 30 days. But posts and stories do remain on your storyline.

Your organization can govern storyline with a number of controls for

• Enablement: storyline can be turned on or off for the organization

• Monitoring: the Storylines page has an “All” view that allows anyone to see all storyline activity, and Microsoft Purview Communications Compliance applies AI to identify potential harassment, bullying, or violation of policy.

• Moderation and response: any user can report a conversation that appears to violate policies and standards, and Microsoft Purview Communications Compliance can automatically create incidents to orchestrate response.

• Security, privacy and compliance: when you are in Native Mode, content can be governed with information policies and ediscovery.

Hopefully this comparison of storyline and stories in Viva Engage + Yammer to consumer social media platforms helps you understand the features and explain them to people familiar with LinkedIn, Facebook, Insta, TikTok and the like.

What questions can I answer for you? What would you want to hear more about? Let me know, here! And if this was valuable, please share it forward, and subscribe!

Share

Subscribe now

Many of my followers are responsible for technology solutions that support productivity and employee experience, including tools like Microsoft 365 and Microsoft Viva. They need to understand our technologies in order to align them with their business objectives, to drive adoption, and to measure success.

In this article, I’ll start with some fundamentals to help you explain to your end users. In later articles, I’ll go into more details to give you a deeper understanding.

Storyline is a feature of Viva Engage, available to most Microsoft 365 customers at no additional charge, that appears across Microsoft Viva and Microsoft 365 apps. You’ll see storyline experiences in Yammer, Microsoft Teams, Outlook, Microsoft Viva Connections, and more.

Your storyline is your place to express yourself, share updates, experiences, knowledge and perspectives with followers and coworkers.

• You can learn more about coworkers from their storylines and what they share. You can follow interesting people to prioritize their activity in your feeds, and you can choose to receive notifications when they share.

• I often describe storyline as “LinkedIn inside your organization”. What you share reaches your followers and coworkers across your company. You can share and discuss internal activity that would not be appropriate to share on public platforms, and you can build relationships that foster connectedness, professional development, and career advancement.

You share with posts or stories.

• Posts often lead with text, and can also contain images, video, links, and attachments—very flexible, very familiar.

• Stories are media-centric posts that lead with a short video (up to 3 minutes in public preview) or photo, though they also support a short description (up to 150 characters in public preview) to facilitate accessibility, search, links, topics and @mentions.

Posts and stories show up in feeds and carousels. You find and view posts in feeds. You find stories in a carousel feed, and they play in an immersive media viewing experience. You’ll find feeds and carousels across Viva Engage (in Teams and Outlook) and Yammer (web and mobile):

• The Home experience, which is a feed of all content from across Viva Engage and Yammer from any community or storyline. The feed is highly personalized to surface and suggest the most relevant content to you.

• The Storylines experience, which zooms in on content only from storylines. There’s a highly personalized feed that includes suggestions, and an even more sharply focused feed of content only from people you follow. And there’s a feed of all storyline content that will be particularly useful to people who “own” the storyline experience for their organizations, allowing you to keep tabs on everything that is being shared.

• Individual storylines, which show content shared by the individual.

• Campaigns—a new features of the Viva suite coming in 2023—will aggregate all content using the campaign #tag from storylines and communities

• Leadership corner—a new feature of the Viva suite coming in 2023—gives each employee a personalized view of their leaders and the content they’re sharing on storylines and in communities.

• You’ll also see feeds and carousels in digests that help you catch up from your Outlook inbox or Teams activity feed.

• You’ll see storyline posts in the Viva Connections feed.

• And you can receive notifications (in email, Teams Activity, or Viva Engage/Yammer bell) for new posts and stories from people you follow—a particularly useful way to stay informed about valuable updates.

Hopefully this gives you enough to understand and explain storyline and stories to your organization and end users. I plan to share more perspectives on how to do so, in future articles. And to share learnings about how our customers are using these capabilities to improve communication, engagement, and connectedness.

What, exactly, do you want to hear more about? What questions can I answer for you? Let me know, here! And if this was valuable, please share it forward, and subscribe!

Share

Subscribe now