Steps:
1. Open AI Studio → System Instruction mode
2. Paste current prompt + 2-3 good output examples
3. Test with new input → compare to desired quality
4. Add constraints based on bad output patterns
5. Export final prompt via "Get Code"

📋 AI Studio example setup:
1. Go to aistudio.google.com → click + Create New
2. Select Freeform prompt or Structured prompt
3. In System Instruction box, paste:
You are an organisational design analyst. Given a department context, produce a structured brainstorm with: - 3 strategic initiatives (title + 2-line rationale) - Risk assessment (high/medium/low per initiative) - Recommended next steps ## Examples of GOOD output: [paste your best output here] ## DO NOT: - Use generic consulting jargon - Suggest initiatives without specific metrics 4. In the User input, type a test prompt like "Engineering team, 45 people, APAC region"
5. Click Run → iterate on the System Instruction until output quality is right
6. Click Get Code (top right) → copies as Python/curl/Node.js API call

Steps:
1. Create a "Prompt Engineer" Gem with meta-prompt expertise
2. Describe your agent's purpose conversationally
3. Take Gem's draft → test in AI Studio
4. Iterate 3-5 rounds between Gem feedback and Studio testing
5. Document final prompt in Google Docs library

💎 How to create a Gem:
1. Go to gemini.google.com → Gem Manager → + New Gem
2. Name it: "Prompt Engineer" (or your domain, e.g. "HR Strategy Expert")
3. Paste this system instruction:
You are an expert prompt engineer. Help me design system instructions for AI agents. For each agent I describe, produce: 1. A structured system instruction (role, context, task, format, constraints) 2. 2-3 few-shot examples 3. Evaluation criteria to judge output quality Ask clarifying questions before drafting. Iterate based on my feedback. 4. Click Save → now chat with it to collaboratively design prompts
5. The Gem remembers your conversation context across messages
Create one Gem per domain: "Org Design Expert", "Technical Architect", "Change Manager", etc.

Steps:
1. Create NotebookLM notebook for your domain
2. Upload: framework docs, gold-standard outputs, terminology guides
3. Ask: "Write a system instruction for an agent that produces X"
4. Generate Audio Overview → listen for missed connections
5. Generate Mind Map → visualise concept relationships
6. Feed back into AI Studio for testing

Steps:
1. Create Generator prompt in AI Studio
2. Create Evaluator prompt (scores output 1-10 + lists issues)
3. In Sheets: Col A = input, Col B = generated, Col C = evaluation
4. Apps Script chains: generate → evaluate → regenerate if score < 7
5. Log improvement patterns → feed back into Generator prompt

Steps:
1. Sheet columns: Entity | Context | Prompt_Template | Output | Rating
2. Apps Script: loop rows, call Gemini API, write outputs
3. Add "Run All" button to Sheet's custom menu
4. Rate outputs → filter failures → adjust template → re-run failures only
5. Once template hits >80% acceptance → lock it as "stable"

Steps (Sheets path):
1. Create one Sheet tab per phase: Phase1, Phase2, ... Phase6
2. Each tab: Col A = input from prior tab's output, Col B = this phase's output
3. Apps Script function: runCascade() executes phases in sequence
4. Human review checkpoint between phases (highlight for approval)
5. Optional: run in Colab for more complex parsing between phases

🚀 Antigravity path:
1. Download Antigravity 2.0 → Create Project → Add your workspace
2. Prompt: /goal "Run a 6-phase agent brainstorm for [department]. Phase 1: analyse org structure. Phase 2: generate insights..."
3. The agent reads your files, generates each phase, and iterates autonomously
4. Use Scheduled Tasks: /schedule "Every Monday 9am, regenerate phase 6 deliverables for Q3 initiatives"
5. Spawn parallel subagents — one per department — to batch multiple cascades simultaneously
Best when: you want the agent to iterate on its own output and self-correct errors.

Steps:
1. Upload document to NotebookLM for initial analysis
2. Use NotebookLM's summaries to identify key sections
3. In AI Studio: upload full doc + system instruction
4. Use Context Caching (API) for repeated queries against same doc
5. Process results back through your prompt pipeline

Steps:
1. Define JSON schema with all required fields, types, and enums
2. In AI Studio: enable Structured Output → paste schema
3. Test with 5+ varied inputs → confirm 100% schema compliance
4. In Gemini API: set response_mime_type: "application/json"
5. In Sheets: parse JSON output into structured columns automatically

Steps:
1. In your prompt, include the beginning of the desired output format
2. Add 2-3 complete examples showing the exact style/structure
3. Add explicit constraints: word count, section names, tone rules
4. Test with diverse inputs to ensure the pattern holds
5. Use temperature=0 for maximum determinism

Steps:
1. Google Docs: Create "Agent Prompt Library" with versioned prompts
2. Gems: Create shared Gems for each agent persona
3. Google Forms: Build input form for non-technical users
4. Sheets: Form responses → trigger generation → results back to Sheet
5. Add a "feedback" column for users to rate/comment on outputs

Steps:
1. Docs: One Doc per agent. Use "Named Versions" for each stable release
2. Sheet: "Prompt Changelog" with Date | Version | Change | Reason | Before/After Score
3. Apps Script: auto-log when the prompt Doc is edited
4. A/B test: run same inputs through V(n) and V(n+1), compare scores
5. Only "promote" new version if it beats the old on your eval set

Steps:
1. Design flow: Trigger (form/timer/edit) → Read inputs → Call API → Write output
2. Apps Script: implement as functions chained by runPipeline()
3. Add "Config" sheet tab: model name, temperature, API key name, prompts
4. Add error handling: retry on 429, log failures to "Errors" tab
5. Deploy as custom menu button OR time-driven trigger
6. Output to: Sheet cells, new Google Doc, or email summary

🌐 Or build as a standalone HTML app:
Use Antigravity / any coding agent to generate a self-contained HTML tool:
/goal "Build me a single-file HTML app that: - Has a form: department name, team size, region - Calls the Gemini API with my system instruction - Renders markdown output in a styled panel - Stores API key in localStorage (user provides once)" Result: a portable HTML file anyone can open locally — no server needed.
Deploy on Cloud Run, GitHub Pages, or simply share the .html file.
This is how the Agent Brainstormer itself was built!

Steps (Agent Studio):
1. Open Agent Studio in GCP Console
2. Define system instruction + tool declarations
3. Draw the reasoning loop on the visual canvas
4. Add branching: if score > threshold → path A, else → path B
5. Test multi-turn in the built-in playground
6. Deploy to Agent Runtime when stable

🚀 Antigravity path (code-first agents):
1. Antigravity 2.0: type your goal and the agent autonomously decides which tools to use, branches on output quality, retries failures
2. With Skills: create .antigravity/skills/brainstorm-cascade.md defining your multi-phase workflow as a reusable skill
3. With Rules: create .antigravity/rules/output-format.md to enforce section headers, scoring tables, etc.
4. Antigravity CLI: agy "Analyse the Engineering function and produce a brainstorm cascade"
5. SDK for programmatic control:
from antigravity import Agent, Tool agent = Agent(model="gemini-2.5-pro", tools=[read_csv, call_api]) result = agent.run("Analyse org chart and produce phase 4 scoring")
Best when: workflow needs file access, command execution, or self-correction loops.

Steps:
1. Define tool schemas (function declarations) for each external API
2. Test in AI Studio with Function Calling enabled
3. Option A: Apps Script + UrlFetchApp for simple integrations
4. Option B: ADK in Colab for multi-tool agents
5. Option C: Cloud Workflows for serverless orchestration
6. Deploy via Agent Runtime or Cloud Run

🚀 Antigravity SDK — connect external APIs:
from antigravity import Agent, Tool @Tool def query_jira(project_key: str, status: str) -> str: """Search Jira issues by project and status.""" resp = requests.get(f"{JIRA_URL}/rest/api/3/search", ...) return resp.json() agent = Agent(tools=[query_jira, read_confluence, push_slack]) Or use MCP servers in Antigravity settings — pre-built connectors for Jira, GitHub, Slack, databases.
Best when: you want the agent to decide WHEN to call each API based on the task.

Steps:
1. Apps Script → Edit → Triggers → Add Trigger
2. Set: Time-driven → Week timer → Monday 9am
3. Trigger function checks for new/changed rows → generates → emails summary
4. Add "Last Run" and "Changed Since" columns for smart re-processing
5. Monthly: review all outputs, update quality metrics

Steps:
1. Create Google Form for input collection (non-technical users)
2. Link Form to Sheet (auto-populates responses)
3. Apps Script: onFormSubmit(e) trigger → read new row → generate → write output
4. Notify submitter via email with results
5. Alternative: onEdit trigger for when a specific cell changes

Steps:
1. Prototype in Colab with ADK quickstart
2. Or use Antigravity 2.0: create a Project, spawn agents with /goal
3. Antigravity SDK: Python scripts for custom agent logic + tools
4. Use Scheduled Tasks (cron) for recurring autonomous runs
5. Deploy to Agent Runtime for production, or keep in Antigravity for dev workflows
⚠️ Only do this after exhausting simpler approaches above.

🚀 Building a persistent agent in Antigravity:

Option 1 — Interactive (no code):
1. Antigravity 2.0 → New Project → Add your folders
2. /goal "You are a weekly sprint planning agent. Each Monday, read JIRA board state, analyse velocity, and produce a sprint plan doc."
3. /schedule "Every Monday 9am" — now it runs autonomously on schedule
4. Review results in the Inbox when you start your day

Option 2 — SDK (programmable):
from antigravity import Agent, Tool, Memory memory = Memory(persist="./agent_state.json") agent = Agent( model="gemini-2.5-pro", memory=memory, tools=[read_jira, update_confluence, send_slack], instructions="You are a sprint planner. Remember past velocity." ) agent.run("Plan next sprint based on current board state")
Option 3 — Gem (simplest, no memory):
1. Go to gemini.google.com → Create a Gem
2. Name: "Sprint Planner". Paste your system instruction
3. Chat with it manually each week — paste board state, get plan back
Choose based on how autonomous you need it: Gem (manual) → Antigravity (autonomous) → SDK (fully custom).