Development_diary and Diary for Context Continuity with Agent Composer

Discussion
1

Some QoL requests and sharing how I DocuGent with Composer Agents (well all AIs actually)

Looking for feedback on my Agenting .rmd farming documentation and explanations.

I have it do extensive project documentation-as-I-go

1332×637 101 KB

And You can see that, for this project, for example - I am building a Roulette Simulator which will use FluidX3D Fluid Dynamics to model the actual ball physics, I have it document from the operations manuals and gaming regulations all the variables the tables actually have, and keep all this in a ‘research’ folder.

The point is - that I have all the projects do such a research tracking, does anyone else?

I also create a project structure and workflow that requires tests, extensive logging and tracking into postgres:

I am not a dev - so this is just how I am doing it - but feedback, advice, criticism welcome;

WANT:

Unique Colors per open Cursor Window – When I have two diff projects open in diff cursor windows - I would like each instance to have a unique color (from a palette I select) such that I know that GREEN is LOCAL project, and RED is remote repo project, and other such UX UI enhancements which I should be able to demand of my Composer Agent to adjust my prefs for me.

Ability to pop out panels to have them work across multiple screens.

So I can pop my terminal box to second monitor etc.

Better clarity on Cursor Rules

A better internal agent logging/diary system as a part of a configurable component in Cursor (see the rest of this post on my diary method) – Maybe this could become a Cursor (VSCode) extension, but first let me know thoughts on the idea.

–

Better UX on the handling of models - e.g. I have no OpenAI API in settings, yet I get “Cannot connect to OpenAI” error at times, sometimes a LOT – I have all the OAI options off in settings. Its only using Claude - and I have an API key in there, yet its set to off due to coaxing by cursor telling me your API key has better feature-set in Cursor - where can I see diff in feature btwn both?

Where is dashboard of calls/actions/tokens/blah blah…

Is this something that I can query via my composer agent?

–

Would like to make multiple agents.

Want to have agents share a DB in my local postgres, whereby I store development_diary.json data…

I’ve been telling my Composer Agent to keep a Diary.rmd and a Development_Diary.json

I have the Agent update these frequently… and they look like:

{
      "date": "2023-12-19",
      "id": "setup_documentation_2023_12_19",
      "title": "Project Setup and Dependencies Documentation",
      "type": "documentation",
      "status": "completed",
      "description": "Created simplified setup guide documenting all project dependencies, environment setup instructions, and automation scripts.",
      "components": [
        "Python virtual environment setup",
        "R package dependencies",
        "PostgreSQL configuration",
        "Common issues and solutions",
        "Environment verification steps"
      ],
      "deliverables": [
        "setup_and_dependencies.Rmd"
      ],
      "tags": [
        "setup",
        "dependencies",
        "documentation",
        "environment",
        "configuration"

AND

title: "Roulette Simulation Development Diary"
author: "Roul-App Development Team"
date: "`r format(Sys.time(), '%B %d, %Y')`"
output:
  html_document:
    theme: united
    highlight: tango
    toc: yes
    toc_depth: 3
    toc_float:
      collapsed: no
      smooth_scroll: yes
    code_folding: show
    includes:
      in_header: header.html
    css: styles.css
    self_contained: no
    lib_dir: site_libs
    dev: svg
    math_method:
      engine: mathjax
      url: "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"
bibliography: references.bib
csl: ieee.csl
---

I make it do extensive headers on all my files as I tend to get distracted and have to come back later - so I have it puke details in case I forget where I left off.

By having them in R Markdown .rmd - I have it do latex/d3/whatever svg visuals in the .rmd - and then RSStudio can render it as HTML and then the Agent can flask it up and build a project website from all the data in the .rmd’s

I have it constantly write and re-write setup and implementation scripts.

I use the Diaries to tell the Agent to go re-familiarize itself with the project via the diaries and it refreshes it back to context fairly OK.

However it still tends to seek shiny objects.

–

I have it produce cli menus to do a lot of various aspects of my tinkerings…

I have it do a daily status report, such as this:

# Roul-App Daily Status Report
Date: 2024-03-19

## Project Overview
A physics-based roulette simulation system using orbital mechanics for high-precision probability mapping.

## Core Design Tenets

### File Structure
- Standard header format:
```python

File: example.py
Version: v0.1.0
Created: 2024-MM-DD
Updated: 2024-MM-DD
Author: Roul-App Development Team
License: MIT

Description:
[Component description]

Dependencies:
- List dependencies
"""


### Development Approach
1. Modular Architecture
   - Separate physics engine from simulation logic
   - Clear separation of concerns
   - Dependency injection for configuration

2. Documentation
   - Development diary (JSON format)
   - Daily status updates
   - Technical documentation in Markdown
   - Inline code documentation

3. Testing
   - Unit tests with pytest
   - Physics validation
   - Statistical verification
   - Performance benchmarking

## Current State: Orbital Mechanics Implementation

### Core Components
1. OrbitalTracker
   - Phase relationship tracking
   - Energy decay calculation
   - Critical transition detection

2. DecayPredictor
   - Descent trajectory projection
   - Coriolis effect modeling
   - Intersection probability calculation

3. ProbabilityMapper
   - Heat map generation
   - Physical constraint validation
   - Confidence interval calculation

### Physics Model
- Two-phase orbital approach:
  1. Stable Orbit Phase
     - Centripetal force
     - Gravitational component
     - Friction loss
     - Angular momentum
     - Energy decay
  
  2. Decay Phase
     - Critical velocity threshold
     - Conservation of angular momentum
     - Gravitational acceleration
     - Coriolis effect

### Database Integration
- Manufacturer specifications loaded from PostgreSQL
- Real-time configuration updates
- Historical data tracking
- Performance metrics storage

## Recent Progress
1. Implemented orbital mechanics core classes
2. Created physics-based probability mapping
3. Integrated manufacturer specifications
4. Added real-time monitoring system

## Next Steps
1. Complete orbital tracker implementation
2. Validate basic orbital mechanics
3. Add decay predictions
4. Generate probability maps
5. Compare with empirical model
6. Validate against FluidX3D

## Development Process
1. Daily Status Updates
   - Progress tracking in development_diary.json
   - Technical documentation updates
   - Code review and validation

2. Implementation Flow
   - Theory development
   - Core implementation
   - Unit testing
   - Integration testing
   - Performance optimization

3. Validation Process
   - Physics accuracy checks
   - Statistical analysis
   - Manufacturer spec compliance
   - GLI-25 standard verification

## Current Challenges
1. Complex phase relationships between ball and wheel
2. Energy decay model refinement
3. Integration of manufacturer-specific variations
4. Real-time performance optimization

## Recent Insights
1. Orbital mechanics provides more accurate probability distributions
2. Phase relationships critical for landing prediction
3. Manufacturer variations significantly impact outcomes
4. Energy decay profiles vary by wheel model

## Tools and Technologies
1. Core Development
   - Python 3.8+
   - Flask for API
   - PostgreSQL for data storage
   - NumPy for calculations

2. Testing and Validation
   - pytest for unit testing
   - FluidX3D for validation
   - Statistical analysis tools
   - Performance profiling

3. Documentation
   - Markdown for documentation
   - JSON for development diary
   - Mermaid for diagrams
   - Rich for CLI output

## Notes
- All physics calculations based on manufacturer specifications
- Probability distributions validated against real-world data
- Performance optimized for real-time analysis
- Modular design allows for easy updates and maintenance

I talk about style_guide.rmd in another comment… (I cant link to it as new user, but interesting concepts on where the IDE-AI world is going to take us. I love it.

If anyone else does this as well with Cursor?

Anyone else have anything similar that they take as an approach?

1 Like
2

are you using the llm to generate this documentation or running a script?

i had a similar idea regarding the repo structure where i just had a script that appends/updates the project tree into the .cursorrules , but it’s hard to say how helpful this is.

TREE_CMD="tree -L 3 --dirsfirst src e2e static"

# Create a temporary file
TMP_FILE=$(mktemp)

# If the command line doesn't exist, append everything
if ! grep -q "^// Command: tree" .cursorrules; then
    cat .cursorrules > "$TMP_FILE"
    echo -e "\n// Command: ${TREE_CMD}" >> "$TMP_FILE"
    eval "${TREE_CMD}" >> "$TMP_FILE"
else
    # Copy everything up to the command line
    sed -n '1,/^\/\/ Command: tree/p' .cursorrules | sed '$d' > "$TMP_FILE"
    echo "// Command: ${TREE_CMD}" >> "$TMP_FILE"
    eval "${TREE_CMD}" >> "$TMP_FILE"
fi

# Replace the original file
mv "$TMP_FILE" .cursorrules

echo "Updated .cursorrules with current codebase structure!"
3

Yes I use the Composer to give directives on exacty how I want it to log, diary and narrate.

I am going to over the xmas break - focus on an agentic control plane using shared postgres db, schema, tables, and git repos for the various tooling that is produced across projects .

I am starting with a DB of all the .rmd, .sql, .py .ps1 files my bots create with descriptions, readme, UUID, function, projects used by etc… catalog as well as the curorrules delineated in a json +postgres - and the primar rules within Cursor IDE will tell it to pull the DB credsfrom .env and go explicitly read these tables, repos, files, in detail to get Composer Bot Archetype/Person/Behavior mode.

4

sounds cool.

have you seen this tool?

…nice starting point to log all calls to sqlite.

5

You’ve got some really interesting ideas here!

Could of questions if you don’t mind?

  • Have you tried using the system prompt with agent mode? I found this didn’t work and have to repeat my instructions each time.
  • The combination of diaries is interesting, but its not clear what you’re using all of them for? Do you have any examples you would mind sharing?