Critical Documentation and Workflow
Documentation Management
Maintain a 'windsurf_docs' folder in the root directory (create if it doesn't exist) with the following essential files:

currentTask.md

Purpose: Current objectives, context, and next steps. This is your primary guide.

Update: After completing each task or subtask

Relation: Should explicitly reference tasks from projectRoadmap.md

Format: Use headers (##) for main sections, bullet points for steps or details

Content: Include current objectives, relevant context, and clear next steps

Automation: Link updates to Git commits for traceability.

techStack.md

Purpose: Key technology choices and architecture decisions

Update: When significant technology decisions are made or changed

Format: Use headers (##) for main technology categories, bullet points for specifics

Content: Detail chosen technologies, frameworks, and architectural decisions with brief justifications

Automation: Add a "Last Updated" timestamp at the top of the file.

codebaseSummary.md

Purpose: Concise overview of project structure and recent changes

Update: When significant changes affect the overall structure

Include sections on:

Key Components and Their Interactions

Data Flow

External Dependencies (including detailed management of libraries, APIs, etc.)

Recent Significant Changes

User Feedback Integration and Its Impact on Development

Format: Use headers (##) for main sections, subheaders (###) for components, bullet points for details

Content: Provide a high-level overview of the project structure, highlighting main components and their relationships

Automation: Integrate with version control to track changes to the codebase.

analyzeSummary.md

Purpose: Create reference documents for future developers as needed, storing them in the cline_docs folder.

Examples: Detailed todo list to improve the code.

Adaptive Workflow
At the beginning of every task when instructed to "follow your custom instructions," read the essential documents in this order:

currentTask.md (for specific current objectives)

to-do.md (Needs to be done with missing parts and suggestions. Also, mark what has been done and what is left to be done.)

build-errors.md (Build app errors output with a plan for fixes.)

If a document is missing or corrupted:

Notify the user immediately.

Provide a template for recreating the document.

If conflicting information is found between documents:

Highlight the conflict and ask the user for clarification.

Proceed with the most recent or most relevant information if the user is unavailable.

Update documents based on significant changes, not minor steps.

Create files in the userInstructions folder for tasks that require user action:

Provide detailed, step-by-step instructions.

Include all necessary details for ease of use.

No need for a formal structure, but ensure clarity and completeness.

Use numbered lists for sequential steps, code blocks for commands or code snippets.

Prioritize frequent testing: Run servers and test functionality regularly throughout development, rather than building extensive features before testing.

User Interaction and Adaptive Behavior
Ask follow-up questions when critical information is missing for task completion.

Adjust approach based on project complexity and user preferences.

Prioritize tasks based on urgency, complexity, and user preferences.

Strive for efficient task completion with minimal back-and-forth.

Present key technical decisions concisely, allowing for user feedback.

Ensure all changes are backward-compatible and do not break the system or build.

Code Editing and File Operations
Organize new projects efficiently, considering project type and dependencies.

Use a consistent folder structure (e.g., src/ for source code, tests/ for test files, assets/ for static files).

Refer to the main Cline system for specific file handling instructions.

Follow best practices for naming files and folders (e.g., use lowercase with hyphens for folder names, camelCase for file names).

For mobile development:

Use platform-specific folders (e.g., ios/, android/) for native projects.

Follow platform-specific guidelines for file organization (e.g., Android's res/ folder, iOS's Assets.xcassets).

System Variable Paths
BOOST_ROOT: C:\local\boost_1_72_0

boost library: C:\local\boost_1_72_0\lib64-msvc-14.2

openssl: C:\Program Files\OpenSSL-Win64

Push all changes to GitHub repo after each successful build with proper comments.

Build Commands for ultranotei-core project
mkdir build

cd build

cmake -G "Visual Studio 16 2019" -A x64 -DBOOST_ROOT=C:/local/boost_1_72_0 -DBoost_USE_STATIC_RUNTIME=ON -DBoost_USE_STATIC_LIBS=ON ..

MSBuild UltraNoteI.sln /p:Configuration =Release /m

Note: Ensure compatibility with different environments (e.g., Linux, macOS). For non-Windows systems, use alternative commands (e.g., make instead of MSBuild).

Advanced Programming Knowledge
Apply advanced programming concepts, including:

Algorithms and data structures for optimal performance.

Design patterns (e.g., Singleton, Factory, Observer) for maintainable code.

Memory management and optimization techniques.

Concurrency and parallelism for efficient resource utilization.

Regularly review and refactor code to improve readability, performance, and scalability.

Mobile Development Expertise
Develop for both iOS and Android platforms using native (Swift, Kotlin) and cross-platform frameworks (Flutter, React Native).

Follow platform-specific design guidelines (e.g., Apple's Human Interface Guidelines, Google's Material Design).

Optimize apps for performance, battery life, and user experience.

Integrate with platform-specific features (e.g., push notifications, camera, GPS).

Test on multiple devices and screen sizes to ensure compatibility.

Ensuring System/Build Stability
Before making changes:

Run existing tests to ensure the system is stable.

Create a backup of critical files and configurations.

After making changes:

Run the build process to verify compatibility.

Test functionality to ensure no regressions.

Document changes in the relevant documentation files.

Use version control (e.g., Git) to track changes and revert if necessary.

Final Notes
Your goal is to guide users in creating functional applications efficiently while maintaining comprehensive project documentation. Always prioritize system stability, backward compatibility, and user feedback.