📝 Lesson 5.2: Comments, Suggesting Mode & Real-Time Co-Editing

In the last lesson you learned to open the door. Now we step inside the room. This is where Google Docs truly shines: several people writing in one live document, talking to each other in the margins, and proposing changes politely instead of silently overwriting. You'll learn the three ways to work together — editing directly, commenting, and suggesting — and, just as importantly, the etiquette that keeps collaboration pleasant rather than chaotic.

📚 What You'll Learn

By the end of this lesson, you will be able to:

Recognize live cursors and presence, and co-edit a document alongside others gracefully
Add a comment on selected text, reply, resolve, and react — and read the comment history
Use @-mention to notify a person and assign work to them
Switch between Editing, Suggesting, and Viewing modes and know what each allows
Propose edits in Suggesting mode and accept or reject suggestions, one by one or all at once
Decide when to comment, when to suggest, and when to just edit directly

⏱️ Estimated Time: 50 minutes · Intermediate

🎯 Project: On a shared document, leave a comment and @-mention someone, switch to Suggesting mode and propose edits, then review the suggestions and accept or reject each one.

In This Lesson

Real-Time Co-Editing: Live Cursors & Presence

Open a shared document at the same moment as someone else and you'll see it immediately: in the top-right, next to the Share button, little colored circles appear — one per person currently in the document, each with their initial or photo. That's presence: Docs telling you who else is in the room right now.

Then watch the page. As your collaborator types, their words appear on your screen, live, character by character. Where they're working, you'll see a colored cursor with their name floating above it — a blue "Maria" bar here, a green "Sam" bar there. Select some text and the same color highlights it. Nobody has to save, nobody has to send; the document simply is the shared, current truth for everyone looking at it. Multiple people can type in different places at once and it all merges seamlessly.

🧠 Mindset

Co-editing feels a little uncanny the first time — someone else's cursor moving through your document can be startling. Relax into it. The document is genuinely big enough for everyone, and Docs never loses a keystroke to a "collision." The skill isn't technical; it's social. Great collaborators treat a shared doc the way they'd treat a shared kitchen: stay aware of who else is working, don't grab the thing someone's mid-way through, and clean up after yourself. That awareness is what we're really building in this lesson.

A little etiquette goes a long way

Because everyone sees everything instantly, small courtesies matter more than they would in a private file:

Don't rewrite the sentence someone's cursor is sitting in. Watch presence; if a colleague is clearly working a paragraph, leave it to them or drop a comment instead.
Announce big moves. If you're about to restructure a whole section, say so in a comment first so nobody is startled when their text jumps.
Use Suggesting mode when the doc isn't yours to freely change — more on that shortly. Silent overwrites are how collaboration turns tense.

We'll come back to etiquette in depth at the end, once you've met all the tools. First, the two ways to work without directly changing the text: comments and suggestions.

Comments: Talking in the Margins

A comment is a note attached to a specific piece of the document that lives in the margin, not in the text itself. It's how collaborators talk about the content without changing it — "Can we shorten this?", "Great line", "Do we have a source for this?". Comments are the conversation layer sitting alongside the writing.

📖 Definition

Comment thread: a comment plus all its replies, anchored to selected text. It stays attached to that text as the document changes, holds a back-and-forth discussion, and can be resolved when the matter is settled — which tidies it out of the margin while keeping it in the history. A thread is a small, self-contained conversation about one spot in the document.

Adding a comment

Select the text you want to comment on. A small comment icon appears at the right edge of the page (a speech bubble with a plus), or you can use Insert > Comment or the shortcut Ctrl+Alt+M (Cmd+Option+M on a Mac). Type your note and click Comment. A colored highlight marks the anchored text, and your note appears in the margin. Anyone with at least Commenter access can do this.

Replying, reacting, and resolving

Reply — click a comment and type in its Reply box to continue the conversation. Threads keep a tidy back-and-forth right where the discussion belongs.
React with an emoji — a quick 👍 or ✅ on a comment acknowledges it without adding another line of text. Small, but it keeps threads from filling with "sounds good" replies.
Resolve — when the point is handled, click Resolve (a checkmark). The thread disappears from the margin, signaling "done." It isn't deleted; it moves to the comment history.

The comment history

Nothing is truly lost. Open the comment history — the speech-bubble icon near the top-right of the document — and you'll see every comment, open and resolved, with replies and timestamps. You can re-open a resolved thread if a matter comes back, and you can scan the whole conversation the document has ever had. This is a genuine record of the thinking behind the writing.

✅ Pro Tip

Resolve comments as they're handled. An open comment means "still needs attention"; a resolved one means "done." Teams that keep the margin tidy always know what's outstanding at a glance. A document drowning in twenty stale comments is one where nobody can tell what still matters — treat "resolve when done" as a shared discipline, not an afterthought.

Suggesting Mode: Propose, Don't Overwrite

Comments talk about the text. Sometimes, though, you don't just want to say "this sentence is clunky" — you want to show a better version, without erasing what the author wrote. That's exactly what Suggesting mode is for. It's Docs' equivalent of tracked changes: every edit becomes a proposal the author can accept or reject.

The three modes

In the top-right of the toolbar there's a mode switcher — often shown as a pencil icon. It sets how your keystrokes behave. There are three modes, and knowing which one you're in prevents a surprising amount of confusion.

Mode	What your typing does	Who can use it
✏️ Editing	Changes the document directly and permanently	Editors (and the owner)
💡 Suggesting	Records every change as a proposal to accept or reject — nothing is final	Editors and Commenters
👁️ Viewing	Nothing — read only, a clean preview with no editing tools in the way	Anyone with access

graph TD A["Mode switcher: how your typing behaves"] --> B["✏️ Editing
changes the doc directly"] A --> C["💡 Suggesting
every change is a proposal"] A --> D["👁️ Viewing
read only, clean preview"] B --> E["Best when the doc is yours
or you are a trusted co-author"] C --> F["Best for review
author accepts or rejects each edit"] D --> G["Best for reading
or presenting without clutter"]

💡 Commenters get real editing power — safely

Notice the crucial detail in the table: a Commenter can use Suggesting mode. That means someone you gave only Commenter access can still propose concrete wording changes — not just comment on them — because their edits arrive as suggestions you approve, never as direct changes. This is why Commenter is such a useful role for reviewers: they can be genuinely helpful with the text while you keep the final say. It ties directly back to the roles you learned in Lesson 5.1.

How suggestions appear

In Suggesting mode, your edits show up in a distinct color (each person gets their own):

New text you type appears underlined in your color.
Deleted text isn't removed — it's shown with a strike-through so the original stays visible.
A note appears in the margin summarizing each suggestion, with Accept and Reject buttons, and room to discuss it like a comment.

Nothing you do in Suggesting mode is final. The author sees a clear before-and-after and decides.

Accepting and rejecting

When you're reviewing suggestions on your own document (in Editing mode), each one has two buttons in its margin card:

Accept (checkmark) folds the change into the document as if it had always been there.
Reject (✕) discards it and restores the original.

For a document full of edits, open Tools > Review suggested edits — its panel has Accept all / Reject all to process everything in one move — handy once you've read through and trust the reviewer's changes.

⚠️ Watch Out

The most common Docs confusion in the world: "why won't my typing stick?" You're almost certainly in Suggesting mode by accident, so every keystroke is becoming a proposal instead of a real edit. Glance at the mode switcher in the top-right and set it back to Editing. Conversely, if you meant to suggest but you're overwriting a colleague's text directly — switch to Suggesting first. Checking your mode before you start typing is a two-second habit that prevents real headaches.

Assigning Tasks & Action Items

A comment doesn't have to be just a remark — it can be a task with an owner. This is where a shared document quietly doubles as a lightweight to-do system, and it starts with the humble @-mention.

@-mention to notify someone

Inside a comment (or in the document body), type @ and start typing a name or email. Docs shows matching people; pick one and their name becomes a linked mention. When you post, that person gets notified — typically an email and an in-app alert — pulling their attention to exactly this spot. It's the difference between hoping someone notices your comment and actually reaching them.

Turning a comment into an assigned action item

When you @-mention a person in a comment, Docs offers a checkbox like "Assign to [name]". Tick it and the comment becomes an action item owned by that person. Now it's not just a note — it's their task. The assignee sees it flagged as assigned to them, and when they've done it they mark it Done, which resolves the thread.

💡 Where assigned tasks surface

Assigned action items don't just sit in the margin. They show up for the assignee in places like their Drive (documents with tasks waiting for them are flagged) and in notifications, so work doesn't get lost in a long document. A document can effectively hold a small, shared task list — "Maria: add the Q3 numbers," "Sam: check this quote" — each one owned, trackable, and resolvable. It's a genuinely underused feature.

⚠️ Important Note: An @-mention notifies and can grant access. If you mention someone who doesn't yet have access to the document, Docs will usually prompt you to share it with them. That's convenient, but it means an @-mention can widen who's in the room — so mention deliberately, and remember the sharing principles from Lesson 5.1 (least privilege, named people). Don't @-mention a stranger into a sensitive document without meaning to.

Working Well Together

You now have three ways to work in a shared document — edit directly, comment, and suggest — plus tasks and reactions. The real skill is choosing the right one for the moment. Here's the honest guidance.

When to comment vs suggest vs edit directly

Situation	Reach for…	Why
It's your own document, or you're a trusted co-author fixing obvious things	Edit directly	Fast and clean; no need to make small fixes into ceremonies
You have an opinion, question, or idea but not a specific rewrite	Comment	Starts a conversation without touching the text
You have a concrete wording change on someone else's draft	Suggest	Shows the exact change while leaving the author in control
You need a specific person to do something	@-mention and assign	Notifies them and makes it a tracked, owned task

✅ Do's

Suggest, don't overwrite, on work that isn't yours. Proposing changes respects the author and preserves their voice — they choose what to keep.
Be specific and kind in comments. "This paragraph repeats the intro — cut it?" beats "confusing." Assume good intent; the other person can read every word you write.
Resolve threads and mark tasks Done as you go, so the margin always reflects what's actually outstanding.
Check your mode before typing — Editing vs Suggesting — so your intent matches what happens.

❌ Don'ts

Don't silently rewrite a colleague's sentence mid-thought — watch presence and use Suggesting or a comment instead.
Don't let comments pile up unresolved. A wall of stale threads hides the ones that matter.
Don't @-mention people into documents carelessly — it can grant access and always sends a notification.
Don't use "Accept all" without reading when the stakes are high; skim the changes first so nothing sneaks in.

💡 Pro Tips

Agree on norms up front for group work: "reviewers use Suggesting, questions go in comments, resolve when done." A shared convention prevents most collaboration friction.
Use emoji reactions to acknowledge comments quickly — it keeps threads short and signals you've seen something without a "noted" reply.

🎯 Project: Comment, Suggest, Resolve

You'll run a full collaboration cycle on a document. The ideal setup is the document you shared in Lesson 5.1 with a friend or a second account of your own — but you can do every step solo by playing both "author" and "reviewer" yourself, switching modes as you go. It's completely non-destructive; you can accept, reject, and resolve to your heart's content.

🏋️ Leave feedback, propose edits, then process them

Objective: Add a comment with an @-mention, switch to Suggesting mode and propose a couple of edits, then review those suggestions and accept or reject each one — so you've used comments, mentions, and Suggesting mode end to end.

Instructions (about 18 minutes):

(3 min) Open your document. Select a sentence, click the comment icon (or Ctrl+Alt+M), and write a real comment — a question or an idea about that text. Post it.
(3 min) Add a reply to your comment that includes an @-mention of your collaborator (or your other account). If Docs offers "Assign to", tick it to turn the comment into an action item.
(3 min) Find the mode switcher in the top-right and set it to Suggesting. Confirm you're in Suggesting mode (edits will show underlined/struck-through in a color).
(3 min) Make two edits: rewrite a phrase, and delete a few words. Notice the new text is underlined and the deletion is struck through, each with an Accept/Reject card in the margin.
(3 min) Switch back to Editing mode. Review your two suggestions: Accept one and Reject the other, and watch the document update accordingly.
(3 min) Finally, Resolve your comment (or mark the task Done), then open the comment history icon to confirm it's recorded there even though the margin is now tidy.

💡 Hint — the three modes and what they do

Mode switcher (top-right pencil icon):

  Editing     -> your typing changes the doc directly
  Suggesting  -> your typing becomes a proposal (accept/reject)
  Viewing     -> read only, clean preview

Feedback tools:
  Comment  (Ctrl+Alt+M)  -> talk ABOUT the text
  @name                  -> notify a person; add "Assign to" for a task
  Suggest                -> SHOW a change without overwriting

Processing suggestions (in Editing mode):
  Accept -> folds the change in
  Reject -> restores the original
  Tools menu -> Review suggested edits -> Accept all / Reject all

If your typing keeps turning into underlined proposals, you're in Suggesting mode — that's the exercise working, not a bug. Flip back to Editing when you're done.

✅ Project Completion Checklist

You added a comment anchored to selected text and posted it
You @-mentioned someone (and tried "Assign to" if offered)
You switched into Suggesting mode and made at least two suggested edits
You accepted one suggestion and rejected another from Editing mode
You resolved the comment and found it again in the comment history

🎯 Quick Quiz

Question 1: You're typing on a colleague's draft and your words appear underlined, while text you delete stays visible with a line through it. What's happening?

Question 2: A reviewer only has Commenter access. Which of these can they still do?

📓 Learning Journal

Keep a learning journal as you work through this course — a separate document, a note, or a page in the document you're building. After each lesson, take a few minutes to write down:

Key concepts you learned
Techniques that clicked for you
Questions or confusion points to revisit
Ideas you want to try in your own documents
Your progress and feelings about learning this — including where your confidence grew

✍️ This lesson's prompt: Think about the last time you gave someone feedback on their writing — an email, a shared file, a printed draft. Which tool would have fit best: a comment, a suggestion, or a direct edit? How did it feel to see edits appear as proposals rather than silent changes? Note one habit — checking your mode, resolving threads, suggesting instead of overwriting — you want to carry into real collaboration.

📝 Lesson Summary

🎓 Key Takeaways

Presence and live cursors show who's in the document and where they're working; co-editing merges everyone's typing seamlessly, so the etiquette matters more than the mechanics.
Comments talk about the text: add on selected text, reply, react, and resolve when done — nothing is deleted, it moves to the comment history.
The three modes — Editing (changes directly), Suggesting (proposals to accept/reject), Viewing (read-only) — determine what your typing does. Check which you're in.
Suggesting mode lets even a Commenter propose concrete edits (underlined additions, struck-through deletions) that the author accepts or rejects individually or all at once.
@-mentions notify people and, with "Assign to," turn a comment into an owned action item that surfaces for the assignee.
Choose the tool for the moment: edit directly on your own work, comment for questions, suggest on others' drafts, assign for tasks — and never overwrite silently.

🎉 What You've Accomplished

You can now collaborate inside a shared document like a pro: reading presence, leaving clear comments, @-mentioning and assigning work, and — the big one — proposing edits in Suggesting mode rather than steamrolling someone's draft. You also know the etiquette that separates smooth collaboration from a chaotic free-for-all. This is the heart of what makes Docs special, and you're fluent in it.

❓ Common Questions at This Stage

Do collaborators get notified about every comment and change?

Not every keystroke — that would be noise. People are notified when you @-mention them, reply to a thread they're in, assign them a task, or (depending on their notification settings) when comments are added. Live edits are visible in real time while you're both in the document but don't fire an email for each one. You can tune notification frequency in the comment settings.

If I reject a suggestion, is it gone forever?

Rejecting restores the original text and removes the proposal from the margin. If you later change your mind, that's exactly what version history is for — you can look back at earlier states of the document and recover wording. We cover that safety net in the very next lesson (5.3), so nothing you do here is truly irreversible.

What's the difference between a resolved comment and a deleted one?

Resolving tidies a thread out of the margin but keeps it — you can find it in the comment history and even re-open it. Deleting removes a comment entirely. Almost always, resolve rather than delete: you keep the record of the conversation, which is often valuable later.

🔭 Looking Ahead

In the next lesson — Lesson 5.3: Version History & Comparing Documents — we cover collaboration's safety net. You'll see the full timeline of who changed what, name and restore earlier versions non-destructively, and compare two documents to spot the differences. It's what makes all this fearless: you can never truly lose good work.

✅ Before the Next Lesson

Make sure you can confidently switch among Editing, Suggesting, and Viewing modes
Leave at least one real comment and one suggestion on a practice document
Write your Learning Journal entry for this lesson

📚 Additional Resources

🌟 Encouragement for the Journey

Collaboration is where writing stops being lonely. You now know how to work shoulder to shoulder with other people in one living document — to propose instead of overwrite, to talk in the margins, and to keep it all tidy and kind. That's a skill teams genuinely prize. Next, we make it all bulletproof with version history. 🤝