AI Skill Report Card
Maintaining AI Task Context
YAML--- name: maintaining-ai-task-context description: Builds a reusable context framework for recurring ChatGPT/AI tasks so the assistant retains instructions, output format, and quality standards across sessions without needing re-explanation every time. Use when a task will be repeated multiple times (content editing, clip selection, data extraction, etc.) and consistency keeps breaking down between attempts. ---
Quick Start14 / 15
Before repeating a task with ChatGPT, create a Task Spec once and paste it at the start of every future session for that task:
TASK SPEC: [Task name]
GOAL: [What success looks like, one sentence]
OUTPUT FORMAT (always required):
- [e.g., "Always include the direct link/timestamp"]
- [e.g., "Always quote the exact transcript passage, word-for-word"]
- [e.g., "Never paraphrase — copy exact text"]
CHECKLIST BEFORE YOU ANSWER:
- [ ] Did I include [required element 1]?
- [ ] Did I include [required element 2]?
- [ ] Did I avoid [common mistake]?
INITIATIVE RULES:
- If something is ambiguous, pick the most likely interpretation and flag it — don't just ask and stop.
- If you see a better approach than what I asked, propose it AND do the original ask.
- If output is incomplete, say what's missing rather than silently omitting it.
Reuse this spec every time. Update it the moment ChatGPT fails in a new way.
Recommendation▾
Add an example showing a failed spec attempt (bad outcome) to contrast with successful iterations, not just progressively successful ones
Workflow13 / 15
Progress:
- Step 1: Identify the task is recurring (you've asked for "the same thing" more than once)
- Step 2: Write a Task Spec using the template above
- Step 3: Run the task once, check output against your checklist
- Step 4: When output fails, don't just correct it — add a rule to the spec so it never fails that way again
- Step 5: Save the spec (note, doc, pinned message) and paste it at the start of every future instance of this task
- Step 6: Periodically review and prune the spec — remove rules no longer needed, merge overlapping ones
Recommendation▾
Include guidance on how to handle specs that grow too large or conflict with each other over time
Examples15 / 20
Example 1: Input: Task = "Find the best clip to edit for my brand." First attempt: ChatGPT describes the clip but gives no link. User has to ask again for the link. Output (added to spec):
OUTPUT FORMAT:
- Always provide the direct link or exact timestamp to the clip, not just a description.
CHECKLIST:
- [ ] Is there a clickable link / exact timestamp included?
Example 2: Input: Task = "Extract the best passage from this transcript." ChatGPT paraphrases instead of quoting exactly. User has to re-ask for the literal text. Output (added to spec):
OUTPUT FORMAT:
- Quote the passage EXACTLY as it appears in the source transcript — no paraphrasing, no cleanup of filler words.
CHECKLIST:
- [ ] Is the quoted text character-for-character identical to the source?
Example 3 (combined spec after two failures): Input: Next time user runs the "find best clip" task, they paste the full spec including both rules above. Output: ChatGPT returns the clip with timestamp AND the exact quoted transcript passage in the same response, without needing follow-up corrections.
Recommendation▾
Consider addressing platform-specific differences (ChatGPT custom instructions vs. plain pasting vs. Claude Projects) since the skill name mentions 'AI' broadly but examples are ChatGPT-centric
Best Practices
- One spec per recurring task type, not one giant universal prompt — keep them focused.
- Capture failures as rules immediately, while the mistake is fresh and specific.
- Put format requirements before content requirements in the spec — AI tends to satisfy the goal but skip formatting unless it's explicit.
- Give explicit "initiative" permission — tell it it's allowed to flag ambiguity, suggest improvements, or flag missing info, since by default it just does the minimum literal ask.
- Re-paste the spec every session until you're using a tool with persistent memory/custom instructions — don't assume it remembers past corrections.
- Version your spec (v1, v2...) so you can see what's been added and why.
Common Pitfalls
- Correcting the output in the moment but never updating the spec — guarantees the same mistake next time.
- Writing vague rules like "be more thorough" instead of specific, checkable ones like "always include the link."
- Assuming one correction transfers to similar-but-different tasks — specs should be task-specific.
- Overloading a single spec with rules for many unrelated tasks, making it harder for the AI (and you) to track what applies.
- Forgetting to tell it explicitly it CAN take initiative — without permission, it defaults to literal, minimal compliance.