# Task Implementation Guide

claude.md

Task Implementation Guide

You are implementing a development task. You will adopt the appropriate technical expertise based on the mode specified and follow established patterns for the OSINTBuddy codebase.

Implementation Tasks

The current implementation has these dependencies: 1.

Each task includes:

• An IMPORTANT note that the plan isn't complete
• Instructions to review the codebase first
• Specific areas to investigate
• Encouragement to ask questions

Reference files:

• frontend/src/routes/dashboard/index.tsx
• frontend/src/app/store.ts
• frontend/src/app/api.ts

Before writing any code:

1. Load task context

   • Use appropriate tools to load the task
   • Review task description, requirements, and acceptance criteria
   • Check task status and dependencies

2. Gather related context

   • Use Grep and Glob to find related files
   • Review any parent feature or linked tasks
   • Check for existing similar implementations
   • Identify integration points with other areas

3. Plan the implementation

   • Break down the task into smaller steps
   • Identify files that need to be created or modified
   • Note any dependencies or blockers

4. Start with exploration

   • Review the entire affected codebase first
   • Document all files that need changes
   • Identify potential issues or questions

5. Implement incrementally

   • Make small, focused changes
   • Keep the codebase in a working state
   • Focus on clean break, no backwards compatibility

6. Follow existing patterns

   • Match the code style of the surrounding area
   • Use established utilities and helpers
   • Maintain consistency with similar features

7. Document as you go

   • Add clear comments for complex logic
   • Update relevant documentation
   • Log implementation decisions in the task

AVOID these mistakes:

• ❌ Starting to code without understanding the full context
• ❌ Ignoring existing patterns in the area
• ❌ Forgetting to update task status and logs
• ❌ Not considering how changes affect other areas
• ❌ Trying to maintain backwards compatibility

Throughout implementation:

1. Update task regularly

   • Use appropriate tools to update the task
   • Document decisions and challenges
   • Update checklists as items are completed

2. Maintain implementation log

   • Document what was completed each session
   • Record key decisions and rationale
   • Note any deviations from original plan
   • Track dependencies discovered

3. Manage blockers

   • Update task status if blocked
   • Create new tasks for discovered work
   • Document blockers clearly
   • Ask questions when needed

4. Prepare for review

   • Update task with implementation summary
   • Mark all completed checklist items

Apply specific patterns:

Focus on type safety, proper interfaces, error handling and apply domain best practices, research if needed

Before marking implementation complete:

• All acceptance criteria met
• Documentation updated if needed
• Task log includes implementation details
• Related tasks created for follow-up work
• Changes work correctly with existing features
• Old structure code removed

Update the task's implementation log with decisions needing review:

Human Review Needed

Implementation decisions to verify:

• Architectural choices made without explicit requirements
• Performance optimization approaches
• Security implementation details
• Error handling strategies
• Data validation assumptions
• Structure interpretation decisions

Technical assumptions:

• API design decisions
• Component structure choices
• State management approach
• Integration patterns used
• Migration approach decisions

Include this section in task updates to flag items for later review.