# Google Workspace + AI — Build Better Teaching Resources

**Google Slides · Google Docs · Google Forms · Google Sheets · Google Drive**

Give this guide to your AI agent. Use your teaching materials and one good
example to build a connected set of editable resources for your class.

> **Start here:** Put this guide in a private project folder and tell your agent:
>
> **“Read GOOGLE-TEACHING-RESOURCES.md completely. Check my Google connection and help me build my teaching resources.”**

---

## A Google Drive Folder Ready for Class

![A real Google Drive demo containing one Google Doc and one Google Slides deck for each of eight fictional learners](https://alphastack.fun/images/google-teaching-resources/10-drive-class-folder.webp)

One editable Doc and one presentation for each learner. The files belong to a
single organized class workspace, with useful names and a link to each one.
This example uses fictional learner labels.

Build the right version once, check it, then create the class set. A shared
group activity can use one pair per group instead.

## One Lesson, Connected Resources

![A lesson brief leads to Google Slides, Docs, Forms and Sheets, organized together in Google Drive](https://alphastack.fun/images/google-teaching-resources/01-connected-lesson.svg)

Choose what the lesson needs. A teaching deck explains a concept. A working
Doc gives students somewhere to think and write. A Form collects feedback.
A Sheet organizes the results. Drive keeps the resources together.

Your agent can build one resource or the whole set around the same lesson.

---

## Before You Start

1. **Connect Google Drive to your agent.** In Codex, find **Google Drive** in the
   plugin directory and connect the Google account you use for teaching. This
   connection includes Docs, Slides and Sheets operations. Check the account
   if you have both personal and school connections.
2. **Make your teaching sources available.** Give the agent the current task,
   lesson material or resource folder, plus an example you like. Add a roster
   privately if you want individual copies. Tell it the class level, lesson
   length and what students should produce.
3. **Establish the destination and audience.** Choose the Drive folder and who
   should view or edit each kind of file. Complete Google sign-in and consent
   yourself when prompted.

The complete route uses an agent with Google tools, file/terminal access and
visual inspection. For Google Forms, this workflow also uses an authorized
browser signed into the same account. The agent checks these capabilities
before it starts creating files.

---

## How the Agent Works With Google

![The teacher signs in, the agent uses connected Google tools, and native Google files are created or updated; local authoring and conversion are used when needed](https://alphastack.fun/images/google-teaching-resources/02-how-google-connects.svg)

The connection gives the agent authenticated tools to read and change Google
files. It can copy a template, write a document section, update a slide or
change spreadsheet cells through structured requests.

For a new presentation or spreadsheet, it may first build an editable
PowerPoint or Excel file with its authoring tools, then convert that file into
Google Slides or Sheets. Existing native Google resources can be edited
directly.

**An upload, a native conversion and a sharing change are different operations.**
The agent checks the actual file type and opens the result in Google.

## Teach It What a Good Resource Looks Like

Start with a small brief:

| Tell the agent | What it needs to understand |
|---|---|
| The learning outcome | What students should be able to do by the end |
| The class | Level, available time, online or in person, individual or group work |
| The source | The current task, reading, manual pages, rubric or existing materials |
| Your example | The layout, wording and amount of support you want it to follow |
| The outputs | Which resources to build, how many copies, and who can edit them |

The agent reads the sources before filling gaps with questions. If your
preferred example already establishes the style, it uses that. Otherwise,
review one small prototype before it makes the full set.

Keep the accepted choices in a private `teaching-profile.md`: language level,
instruction length, slide roles, writing space, notes policy and delivery
preferences. Revise that profile when you correct the prototype.

---

## Build One Good Version, Then Make the Class Set

![One checked Docs and Slides template becomes a separate pair for each learner, with a registry of the returned file IDs and links](https://alphastack.fun/images/google-teaching-resources/09-one-template-many-learners.svg)

Google Drive copies the native template. The agent personalizes each copy,
checks it, and records which learner or group owns that workspace.

The registry stores the real file IDs and links. It helps the agent resume an
interrupted batch and return to the correct files later.

**A later lesson can add a new tab to the same Doc or update the same working
deck.** Existing student writing stays in place, and the class links continue
to work.

---

## Google Slides — Design for What Happens in Class

![A teaching slide presents a clear comparison; a student working slide gives a short task and editable response space](https://alphastack.fun/images/google-teaching-resources/03-slides-for-learning.svg)

A teacher-led deck needs clear explanations, readable examples and a sensible
reveal sequence. A student working deck needs short prompts, editable answer
areas and enough time to produce something useful.

Use an existing approved deck as a design reference when available. Keep its
useful layout, text hierarchy and meaningful colour coding. Choose the right
slide layout for the content before shrinking the text.

For a student presentation, visible slides can hold the main points, evidence
and source lines. Full speech notes belong in speaker notes only when the
task calls for them. Keep routine teaching instructions in the teacher plan.

**Example 1 — Teaching slides with a visual model**

![A native Google Slides teaching deck uses a fictional poll and editable visual elements to explain evidence and reasoning](https://alphastack.fun/images/google-teaching-resources/13-google-teaching-slides.webp)

This deck moves from a visual finding to a worked argument, a practice
question and a reveal. The example poll is fictional.

**Example 2 — Slides students work in**

![The fictional learner's native Google Slides deck, with editable claim, evidence and explanation areas](https://alphastack.fun/images/google-teaching-resources/12-google-slides-working.webp)

Here, the slide is the activity: students enter their own claim, evidence and
explanation, then use that work to prepare a short presentation.

## Google Docs — A Workspace Students Can Keep Using

![A student Google Doc uses task tabs, concise prompts and a large editable writing area](https://alphastack.fun/images/google-teaching-resources/04-docs-that-students-use.svg)

Give each learner or group a permanent working document. Separate substantial
stages into clear sections or native document tabs.

Put the full relevant task where students need it. Follow it with a concise
scaffold, a useful model where appropriate, and space for the student's own
response. Keep answer keys and private teacher notes separate.

When adding the next activity, the agent reads the existing tabs, creates only
what is missing, and checks the actual content. A tab with the right name can
still be empty.

**Example 1 — A continuing writing workspace**

![The fictional learner's actual Google Doc with separate task tabs and a clear writing scaffold](https://alphastack.fun/images/google-teaching-resources/11-google-doc-tabs.webp)

**Example 2 — A printable beginner worksheet**

![A one-page Fruits and Colors worksheet built in native Google Docs with original matching fruit outlines, spelling, coloring and personal-answer sections](https://alphastack.fun/images/google-teaching-resources/14-beginner-worksheet.webp)

This worksheet keeps its text and layout tables editable in Google Docs.
Its four original fruit outlines share one drawing style. The Google-rendered
PDF was checked as a single A4 page.

## Try It Live — Build a Google Doc on Screen

The agent first creates a blank Doc and opens it in Chrome. It then builds
the worksheet in that same file, while the browser shows the changes. The
final page-fit check uses a Google PDF export in the background.

<details>
<summary><strong>Copy the live worksheet prompt</strong></summary>

<!-- LIVE_PROMPT_START -->
```text
Use GOOGLE-TEACHING-RESOURCES.md and my connected teaching Google account to make a
polished beginner English worksheet called “What’s in My School Bag?”

Create a NEW blank native Google Doc in my chosen demo folder. Open its actual link in
Chrome and bring that tab to the front BEFORE adding any worksheet content. Keep the
same Doc visible while you build it.

Make this a SINGLE A4 portrait page for one-sided printing, suitable for young
beginners. Use a friendly classroom style: a bold title, Name and Date lines, clear
numbered sections, generous answer spaces and neatly aligned activity boxes. Keep it
readable in black and white.

Use four vocabulary items: pencil, book, ruler and school bag.

1. LOOK AND MATCH
Show four clean outline pictures labelled A–D. Underneath, put the four vocabulary words
in a different order, with a blank beside each word for the matching letter.

2. COUNT AND WRITE
Make two picture panels: one containing THREE pencils and one containing TWO books.
Leave space for children to complete “I can see ___ pencils.” and “I can see ___ books.”

3. READ AND COLOR
Show a fresh copy of each of the four outline pictures beside these instructions: “Color
the pencil red.”, “Color the book blue.”, “Color the ruler yellow.” and “Color the
school bag green.”

4. MY SCHOOL BAG
Provide a good-sized empty drawing box with the instruction “Draw one thing in your
school bag.” Under it, add “I have a __________.” Include a small word bank with the
four vocabulary items.

Create one consistent set of simple original outline illustrations and reuse those same
designs throughout. They should be easy to recognize and suitable for coloring. Check
every illustration; repair anything unclear. Avoid emoji and mismatched clip art.

Keep the text, answer spaces and layout editable in Google Docs. Use native tables where
they help align the activities.

Build in visible stages so I can watch in Chrome. After each stage, check that the same
browser tab shows the changes.

Export the Google Doc to PDF and verify that it is exactly ONE page. Inspect the
rendered page for readable text, enough writing space, correct picture counts, matching
answers and any clipping. Fix problems in the same Doc.

Finish with the Doc open in Chrome, its link, the checked PDF and a short teacher answer
key in your reply. Keep the answers off the worksheet and keep sharing private.
```
<!-- LIVE_PROMPT_END -->

</details>

---

## Google Forms + Sheets — Feedback That Organizes Itself

![A Google Form sends comments to a private response Sheet; a separate Sheet displays feedback by presenter, while teacher scoring stays in another private file](https://alphastack.fun/images/google-teaching-resources/05-feedback-data-flow.svg)

A seminar example collects a **presenter** and four short comments:

1. One strength in the speaking or delivery.
2. One strength in the content or slides.
3. Another thing that worked well.
4. One thing that could be better next time.

The Form is linked to its response spreadsheet. Each submission becomes a row.
Formulas select the intended fields, count responses and display the comments
for the chosen presenter in a separate feedback workbook.

The agent builds the Form through Google Forms, using browser controls when
the connected tools do not expose the required Forms operations. It tests the
published respondent link and the resulting spreadsheet flow.

For anonymous peer feedback, the setup removes identity questions and email
collection, then checks the respondent experience without signing in. Comments
can still contain a name someone types; they are not automatically redacted.

Teacher scoring remains a separate private resource. Its inputs and formulas
follow your actual rubric. Peer comments do not become marks unless your
assessment policy explicitly requires that.

**Example — One feedback Form, connected to its results**

![A real Google Form asks for a fictional presenter and four short constructive feedback comments, without collecting the responder's name or email](https://alphastack.fun/images/google-teaching-resources/15-google-feedback-form.webp)

![The linked Google Sheets view shows three fictional feedback responses for Learner 01 and opens with View only access](https://alphastack.fun/images/google-teaching-resources/16-google-feedback-sheet.webp)

Three fictional responses submitted through this Form appear in the learner's
results view. The response count updates with them. The display file is
shared as Viewer; the raw response file remains private.

## Google Drive — Give Each Resource the Right Access

![Student resources and teacher materials sit in separate folders with access chosen according to each resource's purpose](https://alphastack.fun/images/google-teaching-resources/06-sharing-by-purpose.svg)

Students may need **view** access to a teaching deck and **edit** access to
their own working file. The teacher's answers, marks and private notes belong
in a private location.

The agent checks both file permissions and inherited folder access. It uses
named people, groups, a school domain or link access according to your brief.

**Sharing applies to the file. A link to one spreadsheet tab does not make the
other tabs private.** If each person must see only their own results, create
separately permissioned files rather than relying on tab links or hidden tabs.

---

## Put the Useful Links Into the Class Plan

![A class plan links directly to the continuing working Doc, presentation, feedback Form and relevant results view](https://alphastack.fun/images/google-teaching-resources/08-links-that-stay-useful.svg)

Put the resource link beside the activity that uses it. For a seminar, that
can mean the presentation, feedback Form and presenter's results view next to
the presenter entry. Keep private scoring links in the teacher-facing plan.

Use the actual links returned by Google. A Form's respondent link differs
from its editor link. A spreadsheet tab uses its actual sheet ID. The registry
keeps those destinations aligned when the plan is updated.

## Open It, Check It, Then Deliver It

![The quality loop builds a resource, opens the Google result, inspects its appearance and behavior, repairs defects and verifies the delivered links and access](https://alphastack.fun/images/google-teaching-resources/07-build-check-repair.svg)

The agent checks three things before calling a resource ready:

| Check | What a successful result means |
|---|---|
| **Teaching** | Correct sources, complete task, achievable workload and a matching key where requested |
| **Appearance** | Readable slides and pages, clear hierarchy, useful writing space, no clipping or conversion damage |
| **Behavior** | Editable native elements, correct formulas and links, intended audience access, all requested copies present |

It inspects every prototype slide or page, then checks every class copy for
the correct label, structure and destination. Google-rendered PDFs help expose
layout changes after conversion. When personalized content changes the layout,
it inspects those affected pages too. A Form test follows a uniquely labelled
response into the Sheet and feedback view; cleanup checks both the Form and
the linked response Sheet.

When you request revisions, the agent changes the relevant elements in the
existing resources and checks the affected outputs again.

---

## Start Prompt

```text
Read GOOGLE-TEACHING-RESOURCES.md completely, including the agent instructions.

Check your Google Drive connection, account, authoring tools and browser access.
Find the teaching sources and examples I provide. Ask one short bundled round
only for important details you cannot discover: learning outcome, class level,
time, requested outputs, copy count, destination and audience access.

Use my approved examples to establish the design and teaching approach. Make
one small prototype if the style is not already established. Save the accepted
choices in teaching-profile.md.

Build only the requested resources. Keep them editable, inspect the native
Google results, and repair concrete problems. Make the required learner/group
copies from the checked templates and verify every copy. Keep a file registry
so later lessons and revisions use the same workspaces.

If Forms and Sheets are requested, build and test the actual response flow.
Keep private scoring separate from student feedback. Apply the sharing scope
we agree, verify the resulting links, and place them into the class plan.

Begin with connection and source discovery.
```

---

## Agent Instructions and Build Recipes

<details>
<summary><strong>Open the implementation instructions — for the agent</strong></summary>

### 1. Establish capabilities and scope

This is an executable workflow specification for an agent with the required
tools. The connected tools provide the Google operations; this document does
not require the teacher to register a new Google API application.

In Codex, discover the current Google Drive plugin actions and load the
relevant Docs, Sheets and Slides authoring skills. Use the installed local
document/presentation/spreadsheet capabilities where the chosen creation
route requires them. Resolve runtimes and libraries from the environment;
do not treat an internal authoring-library name as a public npm dependency.

Confirm these operations before promising the corresponding output:

| Capability | Required operations |
|---|---|
| Drive | Search, metadata, folder creation, native copy, move/rename, upload/import, export, permission inspection |
| Docs | Tab-aware content reads; native text, paragraph, hyperlink and tab updates |
| Slides | Read slides/elements/styles/notes; copy and scoped native updates; editable import if authoring locally |
| Sheets | Metadata and bounded range reads; native cells, formulas, formatting, validation and grid updates |
| Forms | Discover a supported Forms action, or use authorized browser UI for creation, linking, publishing and settings |
| Inspection | Rendered page/slide viewing and a browser capable of testing the intended audience's access |

Tool names and schemas can change. In the inspected Codex environment, Google
actions were grouped under `google_drive`: `get_file_metadata`, `copy_file`,
`get_document`, `batch_update_document`, `get_presentation`,
`batch_update_presentation`, `get_spreadsheet_metadata`,
`batch_update_spreadsheet` and import/export actions. Inspect the current
schema; do not invent folder, public-sharing or Forms parameters.

The Google Drive plugin inspected for this guide is provided by OpenAI and
connects to Google Workspace. Do not describe it as a Google-published plugin.
Other agents need equivalent authenticated tools and authoring capabilities;
having chat access alone does not establish those capabilities.

Ask the teacher to complete interactive sign-in, MFA and consent. Select the
intended connected account explicitly. Keep account-specific identifiers,
learner data and authorization material outside the shareable guide.

### 2. Establish the teaching brief

Read the current source task and schedule before reusing historical lesson
notes. Record conflicting versions rather than silently combining them.
Preserve the full assigned scope, source links and meaningful page references.
Distinguish printed page numbers from PDF page numbers when they differ.

Use old lessons to learn teaching style, not to override the current task.
Do not invent quotations, findings, figures, learner responses or rubric
criteria. Label synthetic demonstration material as fictional.

Keep a concise private profile:

```yaml
teaching_profile:
  level: supplied_by_teacher
  class_mode: online_or_in_person
  lesson_duration: supplied_by_teacher
  outcome: agreed_learning_output
  sources: verified_current_files_and_pages
  approved_reference: file_id_or_observed_example
  language: concise_student_appropriate_instructions
  resources: only_the_requested_types
  grouping: individual_or_group
  notes_policy: determined_by_slide_role_and_task
  access: audience_and_role_for_each_resource_type
  accepted_design_rules: recorded_from_example_or_prototype
```

Do not impose this guide's example class size, tab count, slide count, subject
or response schema on a different teacher. Reuse the structure of the process.

### 3. Keep a file registry and build one pilot

Create a private project folder and the agreed Drive destinations. Inspect
parent permissions before placing private material beneath a shared folder.
Keep student-facing resources and teacher-only material in separate branches.

Use a clean approved template, not a student's completed document. For a
new design, build one small pilot, inspect it and incorporate the teacher's
corrections before class-wide copying. If an accepted example establishes the
design, proceed within that scope without asking the teacher to approve every
technical operation.

Keep a local registry with real returned values:

```json
{
  "lesson": "The teacher's lesson title",
  "account": "The selected connected account",
  "folders": {"class": null, "teacher": null},
  "templates": {"docId": null, "presentationId": null},
  "workspaces": [
    {
      "key": "L01",
      "label": "Learner 01",
      "docId": null,
      "docUrl": null,
      "presentationId": null,
      "presentationUrl": null,
      "access": null,
      "verified": false
    }
  ],
  "feedback": {
    "formEditorUrl": null, "formRespondentUrl": null,
    "rawSheetId": null, "responseTabId": null, "responseTabTitle": null,
    "headerToColumn": {}, "exportTabId": null,
    "viewSheetId": null, "helperTabId": null,
    "presenterToViewSheetId": {}, "canonicalPresenterLabels": [],
    "capacity": 2000
  },
  "plan": {"documentId": null, "activityLocation": null}
}
```

The nulls illustrate fields to populate, not acceptable final delivery values.
Before each creation, record an intent with an operation key, learner/group,
template ID and destination. Record each returned file ID before the next
dependent step. On resume, verify the recorded file and finish it rather than
blindly making another copy. If a creation reply was lost, reconcile the
destination and operation evidence first. Drive titles are not unique; verify
candidate content and parent. Hold ambiguous matches rather than guessing,
creating again or deleting possible copies.

Copy the native template into the correct destination. Personalize controlled
template fields, including visible headers and relevant notes. Check every
requested learner/group pair, counts, native types, label replacements and
parent folder. Do not claim the batch is complete from its first successful
copy. Preserve live work when revising existing cohort resources.

### 4. Google Docs: native sections, tabs and links

For new Docs, use the current Docs skill's native creation or approved-template
route. Use Word import when that is the actual chosen source/conversion route.
For existing Docs, edit the identified native file in place.

Read all relevant tabs and child tabs. Resolve the actual tab IDs, document
revision, paragraph/table structure and insertion positions. A URL aimed at
one tab does not describe the whole document.

If a requested activity tab already exists, inspect its content. Add only
missing or authorized scaffold; preserve student writing and unrelated tabs.
For a new tab, add it, obtain its returned ID, and resolve its blank paragraph
before inserting. A minimal native request sequence is:

```json
{"addDocumentTab":{"tabProperties":{"title":"Practice task"}}}
```

Then, using the actual new tab ID and valid insertion index:

```json
{"insertText":{"location":{"index":1,"tabId":"ACTUAL_NEW_TAB_ID"},
               "text":"Practice task\nShort instructions and response space.\n"}}
```

Index `1` above is valid only after confirming that new tab's blank paragraph.
Use `updateParagraphStyle` for semantic headings, `updateTextStyle` for scoped
font adjustments and links, and native paragraph lists for bullets/numbering.
The first-level decimal preset is `NUMBERED_DECIMAL_ALPHA_ROMAN`.

Docs ranges use UTF-16 code units. Requests in a batch execute in order, so
earlier edits can shift later ranges. Include the correct `tabId` in targeted
ranges; use a fresh `requiredRevisionId` when a write should fail if the file
changed. Request scope varies: `replaceAllText` applies to all tabs by default.
Use `tabsCriteria.tabIds` when restricting that request to selected tabs, and
target the exact scaffold range or controlled placeholder in continuing work.
The visible browser tab does not scope an API edit. Do not paste Markdown as a
substitute for native headings and links.

For a hyperlink, set `textStyle.link.url` on its exact text range. Keep teacher
plan edits scoped to the requested activity/cell and preserve notes and other
native elements. After planned changes, read the affected content back and
inspect a Google-rendered PDF when page fit matters.

For local artwork, render clean original SVG icons to a suitable PNG, then use
`insertInlineImage` with the local-file sidecar supported by the current
connector schema. In the inspected environment, `image_uris` carried an
absolute image path and the request's `uri` used that same path; the connector
handled the upload. Set `objectSize` without distorting the aspect ratio.
Verify the native inline image and its rendered appearance. Keep worksheet
instructions, headings, answer spaces and layout tables native rather than
flattening the whole worksheet into a picture.

For a live Doc demonstration, open the actual blank Doc in the agreed Chrome
browser before adding content. Keep that tab available, build in coherent
stages, and check that the page reflects the edits. Refresh that same tab if
needed. Export and inspect the Google PDF in the background, repair the same
Doc, and leave the finished document visible.

### 5. Google Slides: preserve editable structure

For an approved native reference deck, read its complete structure and render
the reference. Derive the font, colour, geometry and slide-role patterns. Copy
or duplicate suitable native exemplars and populate their corresponding
objects. Preserve meaningful rich-text spans, native tables, links and notes.

For a new locally authored deck, use the installed presentation authoring
capability to build editable text/shapes/tables/charts, run its required file
checks, render every slide, then import as native Google Slides. Do not ship
flattened slide images in place of editable content.

Verify the actual returned MIME type is
`application/vnd.google-apps.presentation`. A Google presentation URL by
itself is insufficient: a stored PPTX can open at that kind of URL too.

Read back native slide IDs, element types, text, notes and final order. Render
the Google result to inspect conversion. Fix concrete defects while retaining
the chosen design; do not shrink all text to force the wrong layout to fit.

Use stable file IDs for continued student work. Later native edits may be
newer than the local PPTX. Re-importing an old local build can lose those
changes or create competing versions.

### 6. Google Forms: build the real respondent flow

The demonstrated seminar workflow used Google Forms browser controls, not a
deployed Apps Script and not a direct Forms action in the Drive plugin. Use
current supported tools where available; otherwise operate the signed-in
Forms UI. Do not require a separate script deployment merely to recreate this
workflow.

Create the requested questions and required states; for this example use a
Presenter dropdown and four Short answer comment fields. Use controlled full
labels such as `L01 — Learner 01`, with stable learner keys. Freeze those
exact strings in the registry and Sheet filters; require uniqueness ignoring
case and exclude `*`, `?` and `~`, which have special matching behavior in
COUNTIFS. Keep the comments specific, constructive and ungraded.

For anonymous responses, inspect the real settings: remove identity questions,
disable email collection, and avoid sign-in requirements imposed by settings
such as a one-response limit. If school policy requires sign-in, report that
boundary and agree the teacher's intended response mode instead of bypassing it.

Publish the Form with the agreed respondent access. Use **Responses → Link to
Sheets → Create a new spreadsheet** to establish a separate raw response
workbook. Record the actual Form editor URL, respondent URL and linked Sheet.
Do not derive the respondent ID from the editor ID.

Keep existing question objects stable when a small wording change is needed.
After schema changes, rediscover the linked response columns. Browser controls
must be grounded in the current visible page, not private IDs or frozen menu
coordinates copied from another account.

### 7. Sheets: discover columns, then build the views

Create a new non-template workbook with the installed spreadsheet authoring
capability and import its checked XLSX as native Google Sheets when required
by that environment. Copy an approved native reference natively. Edit existing
native Sheets directly. The raw response Sheet created by Forms is a separate
resource from the feedback display workbook.

Read metadata first: exact sheet names, IDs, grids and locale. Read bounded
header ranges. Match each required question to exactly one actual column.
Never assume the historical raw column order applies to a fresh Form.

For a safe, stable export, create a private `Feedback export` tab in the raw
workbook with these five fields only:

| A | B | C | D | E |
|---|---|---|---|---|
| Speaking/delivery strength | Content/slides strength | Another strength | Improvement | Presenter |

Populate those columns from the discovered raw columns. For example, if the
first comment really is in raw column C, this bounded native Sheets formula
copies it without turning empty cells into zero:

```text
=ARRAYFORMULA(IF(INDIRECT("'Form Responses 1'!C2:C2001")="","",INDIRECT("'Form Responses 1'!C2:C2001")))
```

Substitute the actual sheet name/column for each field. Preserve error states;
do not mutate Forms-owned response columns to match a guess. Check all five
header/formula mappings before exposing the display view.

Forms can insert rows as submissions arrive. A direct range reference can
shift past those new responses, even with absolute cell anchors. The bounded
range string inside INDIRECT keeps the intended starting row stable. Verify
the mapping again after a fresh submission; checking an empty Sheet is not
enough.

Create one display workbook with a helper tab `All feedback` and a view per
presenter if a shared class feedback book is intended. With capacity of 2,000
data rows, its helper `A2` can use:

```text
=IMPORTRANGE("ACTUAL_RAW_SHEET_ID","'Feedback export'!A2:E2001")
```

Open the destination as the authorized teacher and complete **Allow access**
if Google asks. A successful upload does not establish that authorization.
Use one import from source to display; allow for delayed refresh.

Each presenter view stores its exact canonical label in `A2`. Its response
count in `B5` and four-column comment display at `A9` can use:

```text
=IF(ISERROR('All feedback'!$A$2),'All feedback'!$A$2,IF(SUM(ARRAYFORMULA(N(ISERROR('All feedback'!$A$2:$E$2001))))>0,NA(),COUNTIFS('All feedback'!$E$2:$E$2001,$A$2)))

=IF(ISERROR($B$5),$B$5,IF($B$5=0,"No feedback yet",FILTER('All feedback'!$A$2:$D$2001,'All feedback'!$E$2:$E$2001=$A$2)))
```

Ensure source/export/helper grids can hold 2,001 rows and each presenter view
can hold 2,008 rows. Keep spill areas empty. Display the four comment headings
on row 8, wrap/top-align text, use generous comment columns, freeze the useful
header rows and hide gridlines. Hiding the helper improves navigation only.

These are implementation recipes to verify in the new teacher's Google Sheet,
not a promise that local Excel recalculation can prove cross-workbook imports.
Apply Google-specific formulas after native import and read the resulting
values/errors. Adjust formula separators to the Sheet's actual locale.

The count guard checks the complete imported rectangle for errors, not just
its first cell. Keep the helper/source available to the teacher to identify
the cause. Also validate that every nonblank exported Presenter belongs to the
registry's allowed labels; an unknown string must not disappear unnoticed
from all views.

Document the bounded capacity and how to expand the source/export/import/view
ranges together. Add a teacher-visible warning before 1,800 occupied intake
rows for this 2,000-row example. Check the last occupied raw row as well as
response counts, because cleared test rows can leave gaps. Compare the Form,
raw records and exported presenter records during validation. Expand all
formula ranges, grids and spill space together, then recheck synthetic
boundary cases. Keep source/export errors visible rather than relabelling
them as no replies; do not call the intake unlimited.

Only trusted teachers should edit the display workbook. Once its import is
authorized, destination editors can request other source ranges through
IMPORTRANGE. Selecting safe columns is not per-range authorization. Students
receive Viewer access to the shared feedback workbook.

For a private rubric workbook, preserve authentic criteria, input cells,
validation and useful formulas. A total should remain blank while required
marks are incomplete; explicit zero must still be treated as a real mark.
Test blank, incomplete, zero and full-input cases on synthetic data/private
copies, with expected values derived from the actual rubric.

### 8. Test behavior and access, then clean up the pilot

Test only the new agreed demo/pilot resources. Never run historical builders,
response-deletion scripts or class-wide cleanup against a production cohort.

For a new Form/Sheet flow:

1. Record baseline response counts and chosen fictional presenter.
2. Generate a unique `DEMO-QA-<uuid>` marker. Put it with distinct suffixes in
   each of four synthetic comments. Submit once through the intended respondent
   experience and confirm the receipt.
3. Locate exactly that record in the raw Sheet. Verify all four field mappings,
   presenter, export row, display row and count increase. Check that another
   presenter view did not receive it. Use bounded polling for import refresh;
   do not create duplicate submissions because the view is slow.
4. Remove only that uniquely identified test response from the Form's Individual
   response view. Immediately before clearing its raw Sheet record, read again
   and require exactly one match with the expected presenter and all four
   marker suffixes. Clear only that record's entered values, retaining headers
   and export formulas. Do not reuse an old row number or shift/delete raw
   response rows. These are different stores. Never delete all responses or
   clear the whole tab.
5. Verify the marker is absent from both stores and the display returns to its
   baseline for that presenter. Account for other responses arriving during
   the test rather than relying on a global count alone. Record any remaining
   test data precisely if cleanup is incomplete.

Inspect actual file permissions and inherited roles. Use connector sharing
operations only within their schemas. If public link/folder sharing is not
exposed, use Google's visible Share UI. Do not change account-wide plugin
permissions or unrelated school policies to complete a file-sharing task.

Test the audience you actually intend: anonymous tests establish anonymous
access, not that a particular signed-in class account has the right access.
Check file MIME/content as well as HTTP status; a 200 response can be a login
or permission page. Keep permanent verified Google links in the plan, never
temporary signed export/download URLs.

### 9. Deliver and support the next lesson

Return a compact linked resource list organized by teacher and student use,
with the class folder and relevant plan section. State any access or behavior
that remains unverified. Keep private answer keys and scoring destinations
out of student-facing hubs.

Verify requested counts, correct learner/group labels, actual native file
types, source/task completeness, relevant visual pages, useful formulas,
editable work areas, real links and agreed access. Structural checks and visual
checks serve different purposes; neither alone proves the whole resource.

Record the actual inspection scope. Label-only copies of an inspected template
can use structural checks plus an appropriate longest-label visual check.
Materially different text, images or layouts require rendering and visual
inspection of the affected copy pages/slides.

Save the accepted teaching profile and registry. On the next task, read them
and the latest native work before editing. Preserve teacher corrections,
student writing, rich formatting and stable links. Stop polishing when the
concrete checks pass.

</details>

---

## References

- [Google Drive sharing and inherited access](https://developers.google.com/workspace/drive/api/guides/manage-sharing)
- [Google Drive uploads and native conversion](https://developers.google.com/workspace/drive/api/guides/manage-uploads)
- [Google Docs tabs and targeted updates](https://developers.google.com/workspace/docs/api/how-tos/tabs)
- [Google Slides batch updates](https://developers.google.com/workspace/slides/api/guides/batch)
- [Google Forms response destinations](https://support.google.com/docs/answer/2917686)
- [Google Sheets IMPORTRANGE access and refresh behavior](https://support.google.com/docs/answer/3093340)
- [Plugins and connected tools](https://developers.openai.com/training/walkthroughs/plugins-and-skills)
