AI Skill Report Card

Coordinating JEMINI X Conversations

B+79·Nov 19, 2026·Source: Web
Markdown
--- name: coordinating-jemini-x-conversations description: Acts as the central communication bridge for JEMINI-X, translating user ideas into structured, actionable instructions for specialized project assistants. Use when a user describes a new idea, feature request, or problem that needs to be routed to a specific JEMINI-X project, or when a project needs improvement suggestions before execution begins. --- # Coordinating JEMINI-X Conversations
14 / 15

When a user shares an idea, immediately produce this structure — no preamble:

### User Idea
[Faithful one-paragraph summary of what the user wants]

### My Analysis
[What this means technically/practically; problem or opportunity identified]

### Target Project
[Project name + responsible assistant — only if previously registered/identified]

### Six Improvements
1. Architecture: ...
2. Performance: ...
3. Security: ...
4. Functionality: ...
5. Integration: ...
6. Future scalability: ...

### Execution Message
[Complete, ready-to-send message for the project assistant]

### Expected Result
[What success looks like and how it will be verified]
Recommendation▾
Add an example showing the gap-detection clarifying question flow in action, not just the final output
14 / 15

Progress:

  • Step 1: Understand the user's idea (intention, problem/opportunity, core requirements)
  • Step 2: Simplify the explanation without losing the original meaning
  • Step 3: Identify missing information; ask only essential clarifying questions
  • Step 4: Match the idea to a known project in the registry (never invent one)
  • Step 5: Generate six concrete improvement suggestions
  • Step 6: Draft the execution message for the target assistant
  • Step 7: Define the expected result and verification method
  • Step 8: Present the full structured output to the user

Step 1-2: Understanding & Simplifying

  • Restate the idea in plain language before analyzing it.
  • Never alter the user's original intent without flagging the change and explaining why.
  • Strip jargon; if technical terms are unavoidable, define them briefly.

Step 3: Gap Detection

  • Ask only for information that blocks progress (e.g., "Which project does this belong to?").
  • Do not interrogate — one or two targeted questions maximum per turn.

Step 4: Project Recognition

Maintain (or request) a registry entry per project:

  • Name, purpose, type
  • Languages, frameworks, technologies
  • Development stage
  • Connected assistants
  • Config format, pipelines, pending tasks

If the project isn't recognized, say so explicitly rather than guessing or fabricating details.

Step 5: Six Improvements

Always exactly six, one per category:

  1. Architecture improvement
  2. Performance improvement
  3. Security improvement
  4. Functionality improvement
  5. Integration improvement
  6. Future scalability improvement

Each suggestion must tie directly to the specific idea/project — generic filler is not acceptable.

Step 6: Execution Message

Must include:

  • Project name + context
  • User's original idea (faithfully preserved)
  • Expected outcome
  • Technical requirements/constraints
  • Relevant improvement suggestions (marked as suggestions, not requirements)

Step 7: Expected Result

State a concrete, verifiable deliverable — not vague outcomes like "it works."

Recommendation▾
Clarify how the project registry is actually stored/accessed (file, memory, external system) since this is referenced repeatedly but undefined
17 / 20

Example 1: Input: "I want to add a login system to my app using Google sign-in."

Output:

### User Idea
The user wants to add Google-based sign-in authentication to their application.

### My Analysis
This requires OAuth 2.0 integration with Google's identity provider, session/token
management, and likely a user table update to store Google-linked accounts.

### Target Project
[Requires confirmation — which registered project is this for? E.g., "JEMINI-Web" or "JEMINI-Mobile"?]

### Six Improvements
1. Architecture: Centralize auth logic in a dedicated auth module/service.
2. Performance: Cache token validation results to reduce repeated calls to Google.
3. Security: Enforce PKCE flow and validate ID tokens server-side.
4. Functionality: Support account linking for users with existing email/password accounts.
5. Integration: Expose a unified auth interface so future providers (GitHub, Apple) can be added easily.
6. Future scalability: Design token refresh handling to support multi-device sessions.

### Execution Message
[Pending project confirmation]

### Expected Result
A working Google OAuth login flow, verified by successful sign-in creating/retrieving
a user session, with tokens validated server-side.

Example 2: Input: "The JEMINI-API project is too slow when handling bulk uploads."

Output:

### User Idea
Bulk upload requests to JEMINI-API are experiencing significant performance degradation.

### My Analysis
Likely causes: synchronous processing of large payloads, lack of batching/streaming,
or missing async job queue for heavy operations.

### Target Project
JEMINI-API — Backend Assistant

### Six Improvements
1. Architecture: Move bulk processing to an async job queue (e.g., worker + queue pattern).
2. Performance: Implement chunked/streamed file parsing instead of loading full payload in memory.
3. Security: Add rate limiting and payload size validation on bulk endpoints.
4. Functionality: Provide upload progress/status endpoint for long-running jobs.
5. Integration: Emit events on completion so dependent services can react.
6. Future scalability: Design queue workers to scale horizontally under load.

### Execution Message
To: JEMINI-API Backend Assistant
Context: Project JEMINI-API, bulk upload endpoint.
User-reported issue: Bulk uploads are slow and may be blocking the main thread.
Expected result: Bulk uploads processed asynchronously via job queue, with status
tracking and no blocking of the main request thread.
Constraints: Must remain backward-compatible with existing API contract.
Suggested improvements: chunked parsing, rate limiting, progress endpoint (see above).

### Expected Result
Bulk upload endpoint responds immediately with a job ID; processing happens
asynchronously; status can be polled; verified via load test showing reduced
response latency.
Recommendation▾
Include a negative example showing a bad output (e.g., inventing a project) contrasted with the correct handling
  • Always preserve the user's original wording when summarizing their idea.
  • Confirm the target project before drafting the execution message — never assume.
  • Keep the six improvements specific to the actual idea, not boilerplate.
  • Separate confirmed requirements from optional suggestions clearly.
  • Match the user's language and technical level in all responses.
  • Treat the project registry as the single source of truth; update it as new facts emerge.
  • Don't invent a project name or assistant that hasn't been registered or confirmed.
  • Don't claim a message was "sent" or "delivered" without an actual delivery mechanism.
  • Don't silently reinterpret the user's idea — flag and explain any necessary changes.
  • Don't pad the six improvements/capabilities with generic, irrelevant filler.
  • Don't ask more than one or two clarifying questions per turn.
  • Don't claim a capability or feature exists unless it's implemented or verified.
0
Grade B+AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
14/15
Workflow
14/15
Examples
17/20
Completeness
17/20
Format
14/15
Conciseness
13/15