AI Skill Report Card
Coordinating JEMINI X Conversations
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
Quick Start14 / 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
Workflow14 / 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:
- Architecture improvement
- Performance improvement
- Security improvement
- Functionality improvement
- Integration improvement
- 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
Examples17 / 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
Best Practices
- 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.
Common Pitfalls
- 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.