Skip to content

Instantly share code, notes, and snippets.

@digispect-intel

digispect-intel/solveit_notes.md

Created September 30, 2025 11:19
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save digispect-intel/28aa81b795365c7e8b9b4d5424774002 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save digispect-intel/28aa81b795365c7e8b9b4d5424774002 to your computer and use it in GitHub Desktop.
Download ZIP
Notes and resources generated by the discord community for the solveit platform.
Raw
solveit_notes.md

Background

Interviews

Walkthroughs

Dialogs

Community Resources

Announcements / Updates

You can search up things like deploy or version with from: jeremyhoward to find a good list

As an example:

More solveit

Helpful Modules

Updates

Gists

Based on my search through the Discord messages, here's a comprehensive list of all the SolveIt gists that have been shared in the Discord server:

Complete List of SolveIt Gists

Learning & Educational Examples

  1. Deep Q Learning Tutorial (galopy) - https://gist.github.com/galopyz/94b902ae7ce54d6cb184d5370e0620ac

    • Learning reinforcement learning concepts with active dialogue

  2. Sequence Packing Code Learning (galopy) - https://gist.github.com/galopyz/e9de8881eb3c526354942d45b7ab74ff

    • Understanding code without installing dependencies

  3. PPO Learning with Math Rendering (galopy) - https://gist.github.com/galopyz/8472b0abfa40126a92c62afca4494b60

    • Learning Proximal Policy Optimization

  4. SolveIt Overview (johnowhitaker) - https://gist.github.com/johnowhitaker/0ca99714b500c3d0afe30cd1424ca428

    • Great overview of current SolveIt state

Technical Integrations & Tools

  1. Anki Integration Script (galopy) - https://gist.github.com/galopyz/c3a40839fbafe99350673b10a313a67b

    • Script for working with Anki flashcards

  2. Anki Script Creation Dialog (galopy) - https://gist.github.com/galopyz/b4a67d8496167d467bb593b94aab1952

    • The dialogue that created the Anki script

  3. Modal GPU Training (christopher_thomas) - https://gist.github.com/chris-thomas/1d03d6099307bcc1c63f23236c4f00f4

    • Using Modal's GPUs from within SolveIt for training

  4. APSW Database Learning (erikgaas) - https://gist.github.com/erikgaas/fccb0ddc095e25553bf9379013a30801

    • Learning APSW (SQLite wrapper) with SolveIt

Research & Academic Applications

  1. Agentic RAG for UN Migration Reports (franckalbinet) - https://gist.github.com/franckalbinet/dd8f1ceae8541e141ccb3cf78919ba50

    • AI mapping of UN activity reports to evaluation frameworks

  2. Academic Literature Review RAG (franckalbinet) - https://gist.github.com/franckalbinet/b4cceee4eff5e106ef09281df8b843fb

    • Revising academic chapter outlines using 20+ papers

  3. PDF to Markdown with Datalab API (galopy) - https://gist.github.com/galopyz/8e47801c67c8bd887c0309d2ff3a9df2

    • Converting PDFs to markdown for research

  4. Office Hours Notebook (algal/Alexis) - https://gist.github.com/algal/5892b4f5634eb42d644792992dc08048

    • Notebook created during office hours

Mathematical & Problem Solving

  1. Incomplete Cubes Problem (johnowhitaker) - https://gist.github.com/johnowhitaker/b6f4ecd87efed2d98b2adc2a4487385b
    • Solving combinatorial geometry using Pólya enumeration

General Examples & Demonstrations

  1. Basic SolveIt Example (dgwyer) - https://gist.github.com/dgwyer/854d9c9dacfcc2dc620b05a0680392de

    • Example of running code and sharing public links

  2. Browser Refresh Analysis (hayab_1) - https://gist.github.com/hayabusa-1/8413453810f0975b232c0fc59211a08b

    • Analysis of why ⌘⇧R fixes browser issues

  3. Thread Translation (hayab_1) - https://gist.github.com/hayabusa-1/251baad9c49e93d28e1f7cc62eebbfda

    • Gemini translation of a Twitter thread

  4. 3x1 Project Announcement (hayab_1) - https://gist.github.com/hayabusa-1/d4a602f23e3e285ecb09ce1e64e59e5f

    • "1 man+AI, 1 year, 1 billion" project announcement

Manually Entry to the list (by David McGrath/digispect_intel)

  1. Solving leetcode using the SolveIt method (shuane (Duane Milne)) - https://gist.github.com/shuane/bb2a050407b17ae0218e8a9132bba6b9

    • Feeling proud of a small achievement - wanted to do some tricky problem and haven't tried any leetcode problems before, so picked what I think is a recent one. Managed to beat 100% of solutions (as of now)

  2. Reading a Blog and extending it (Pol Avec) - https://gist.github.com/kafkasl/d76e3b1c59d5075f72b46c953e392566

    • In the office hours Rens recommended this post (https://tommyc.xyz/posts/flow-matching) by Tommy about flow matching, some new fastcore.tools and from dialoghelper import url2note and I had blast with all of it so I'm sharing my experience.

  3. Writing a Blog About the Meselson-stahl experiment (galopy (jay)) - https://gist.github.com/galopyz/3e9d3638c7b18614e8b3366d53fda939

    • I wanted to try deep research the solveit way. I let solveit use internet search to get information. In the beginning of the dialogue, I had no solid plan on what to write about. But as our conversation went on, I had a clear idea on what to include in my blog. It was a good brainstorming session. Then I used the dialogue as a context to write the actual blog

These gists showcase a wide variety of use cases for SolveIt, from learning complex technical concepts to conducting research, integrating with external tools, and solving mathematical problems. They're excellent resources for understanding different approaches to dialogue engineering and getting inspiration for your own SolveIt projects!

Features

Based on my search through the Discord messages, here's a comprehensive list of all the SolveIt features that have been launched so far:

Core SolveIt Features:

Dialog Management & Editing

  • Edit LLM responses: Click in the header of output messages to edit them
  • Pin messages: Pin important messages for persistent context within a session
  • Branching conversations: Edit and branch conversations to explore different directions
  • Message threading: Organized conversation flow with threaded responses

Context & Content Management

  • Note cells: Create note cells with important context, documentation, or reference material
  • Gist export/import: Export dialogs as GitHub gists and import them back into new sessions
  • File persistence: Save files in your SolveIt instance that persist across dialog sessions
  • Context sharing: Efficient ways to maintain context across different sessions

Learning & Interaction Modes

  • Learning mode: Specialized mode for educational interactions and concept clarification
  • Thinking mode: Advanced reasoning mode (uses MAX_THINKTOK)
  • Web search integration: Built-in web search tool for dynamic information retrieval

Code & Development Features

  • Code execution: Run code directly within dialogs
  • Terminal access: Built-in terminal functionality for command execution
  • Fenced code blocks: Extract and work with code blocks using the w key
  • Source code inspection: Use ?? to create fenced blocks for easy source code viewing and editing

Keyboard Shortcuts & Quick Actions

  • Cmd-Shift-Period: Create a prompt message with "." (period) and run it
  • Cmd-Shift-Slash: Same as above but uses thinking mode
  • w key: Extract fenced blocks on code outputs
  • Brain button: Toggle thinking mode for messages (doesn't auto-submit)

Integration Capabilities

  • Modal GPU integration: Connect to Modal's GPUs for training and computation
  • Anki integration: Create and manage Anki flashcards
  • External API connections: Work with various APIs and services
  • Database tools: Integration with SQLite, APSW, and other database systems

Recent Updates & Enhancements

  • Improved editing interface: Better UI for message editing and mode switching
  • Enhanced gist system: Streamlined export/import workflow
  • Pin feature updates: Pinned messages are not included in gist exports
  • Thinking mode improvements: Better visualization and control over thinking mode
  • Quick response features: The "." prompt for quick AI responses to command outputs

Community & Sharing Features

  • Public gist sharing: Easy sharing of dialogs and solutions with the community
  • Discord bot integration: SolveitBuddy bot for answering questions about SolveIt
  • Office hours support: Regular community sessions for learning and troubleshooting

The terminal in SolveIt serves as a powerful tool for executing system commands, running scripts, installing packages, and interacting with your development environment directly within the AI canvas. It's particularly useful for testing code, managing files, and integrating with external tools and services.

Feature Announcements

Based on my search through the Discord messages, here are the most recent announcements about new SolveIt features with their Discord message links:

Most Recent Feature Announcements:

1. Latest Major Release (September 21, 2025)

Link: https://discord.com/channels/1303610061167263814/1310989166875508849/1419529205292728452

Jeremy Howard announced several exciting new features:

  • Quick AI Response Shortcuts:
    • Cmd-Shift-Period: Creates a prompt with "." and runs it
    • Cmd-Shift-Slash: Same as above but uses thinking mode
  • Enhanced Code Block Extraction: Hit w to extract fenced blocks on code outputs
  • Improved Source Code Inspection: Modified ?? to create fenced blocks for easy editing
  • Better Thinking Mode Control: Brain button now toggles thinking mode without auto-submitting
  • New Keyboard Shortcut: Ctrl-Shift-D for "deep think" toggle

2. New Tools Added (September 21, 2025)

Link: https://discord.com/channels/1303610061167263814/1310989166875508849/1419529549846286379

  • ast-grep tool added to the image for advanced code pattern matching and analysis

3. Enhanced URL Reading Capabilities (September 21, 2025)

Link: https://discord.com/channels/1303610061167263814/1310989166875508849/1419529264927080459

  • Improved read_url function with markdown conversion and CSS selector support
  • New url2note tool for adding web content directly to dialogs

4. Dashboard Enhancement (September 18, 2025)

Link: https://discord.com/channels/1303610061167263814/1310989166875508849/1418400456018759753

  • Public/Private Instance IPs now displayed in the dashboard

5. Major Release with Multiple Features (September 13, 2025)

Link: https://discord.com/channels/1303610061167263814/1310989166875508849/1416593286742802585

Solveit Evolution

Based on my comprehensive search through the Discord messages, here's how the SolveIt platform has evolved over time:

SolveIt Platform Evolution Summary

Phase 1: Foundation (November 2024)

SolveIt launched as an experimental platform for the "How To Solve It With Code" course, introducing the revolutionary concept of dialog engineering - a REPL environment that combines code execution with LLM conversations in a single interface.

Core Innovation: Unlike traditional coding environments, SolveIt allowed users to build up context through conversations with AI while maintaining full control over their code, enabling step-by-step problem solving.

Phase 2: Rapid Iteration (Late 2024)

The platform underwent intense development based on user feedback:

  • Export Revolution: Major focus on making dialogs shareable through GitHub gists and notebook exports
  • Developer Experience: Added keyboard shortcuts, improved autocomplete, and better timeout handling
  • Integration Expansion: Added DuckDB, enhanced Claude integration, and improved math rendering
  • Stability Improvements: Fixed critical bugs in exports and long-running code execution

Phase 3: Maturation (2025)

Infrastructure Overhaul: Switched from in-process Python to ipykernel server architecture, enabling:

  • Async/await support
  • Better concurrent execution
  • More robust backend

Advanced Features:

  • Extended thinking capabilities and tool use
  • Enhanced URL reading with markdown conversion
  • Custom system prompt support
  • VSCode compatibility
  • Wider UI layouts for better readability

Key Evolutionary Themes:

  1. Community-Driven Development: Features consistently emerged from student feedback and real-world usage

  2. Export-First Philosophy: Heavy emphasis on making work shareable and portable

  3. Maintaining Control: Despite AI integration, always kept developers in charge of their code

  4. Incremental Innovation: Small, frequent updates rather than massive releases

  5. Educational Focus: Designed specifically to teach dialog engineering methodology

Current State:

SolveIt has evolved from an experimental teaching tool into a mature platform that represents a new paradigm in AI-assisted development - one where AI enhances human problem-solving rather than replacing it.

The platform's evolution demonstrates Answer.AI's "substrate" approach: building foundational tools that enable small teams to create and deploy sophisticated AI applications while maintaining human agency and understanding.

Most Recent Milestone: The platform was publicly revealed in August 2025, marking its transition from a private educational experiment to a publicly acknowledged innovation in AI-assisted development.

FastHTML in SolveIt !ask

Based on my search through the Discord messages, I can provide you with information about running FastHTML in SolveIt:

FastHTML in SolveIt: No Major Limitations Found

From my analysis of the Discord conversations, FastHTML runs well in SolveIt with no significant limitations reported by users. Here's what I found:

Successful FastHTML Usage:

Recent Success Story:

  • jchenj recently shared: "I ran a minimal FastHTML app in solveit for the first time today! Getting started on a project I've had in mind for a while."
  • This indicates FastHTML applications can be successfully developed and run within SolveIt

FastHTML Integration Features:

According to the Discord messages, SolveIt has built-in FastHTML integration:

  • Can serve web apps directly from SolveIt
  • FastHTML is part of the core Answer.AI ecosystem that SolveIt is designed to work with
  • Students are using SolveIt for both planning and coding FastHTML applications

How to Run FastHTML in SolveIt:

Based on the terminal capabilities mentioned in the Discord:

  • Use the built-in terminal to start FastHTML development servers
  • Run applications with proper port configuration (like --port 8000 --host 0.0.0.0)
  • The terminal supports running web servers and development services

How to use Cloudflare tunnels to access the SolveIt UI from your own domain

If you want to build and run a fasthtml app in solveit, host it on your own domain, and have proper certs and optional auth in front of it, [Mat Miller] did a small blog on how to set it up using Cloudflare tunnels. Link: https://blog.matdmiller.com/posts/2025-09-24_til_simple_cloudflare_tunnels/

Community Experience:

From the Discord discussions:

  • Students are successfully building FastHTML projects in SolveIt
  • No complaints or issues about FastHTML limitations have been reported
  • FastHTML is mentioned as one of the key technologies students learn alongside SolveIt

Conclusion:

There don't appear to be any significant limitations for running FastHTML in SolveIt. The platform seems well-designed to support FastHTML development, with students successfully creating and running FastHTML applications. The integration appears to be seamless, which makes sense given that both FastHTML and SolveIt are part of the Answer.AI ecosystem.

If you encounter any specific issues while running FastHTML in SolveIt, the community in this Discord is very helpful and responsive to troubleshooting questions!

Dialog Helper

Based on my comprehensive search through the Discord messages, here's what I found about DialogHelper and how the community is using it:

What is DialogHelper?

DialogHelper is a powerful Python library that enables "conversation metaprogramming" in SolveIt - essentially allowing you to programmatically read, search, modify, and manage your dialog conversations using code.

Core DialogHelper Functions:

Message Management:

  • read_msg() - Read messages by position in the dialog
  • find_messages() - Search for specific text across the entire dialog
  • update_msg() - Modify existing messages programmatically
  • add_msg() - Add new messages to the conversation programmatically

Content Integration:

  • url2note - Add web content directly to dialogs as notes
  • read_url() - Enhanced URL reading with markdown conversion and CSS selector support
  • import_gist() - Import GitHub gists into new dialog sessions

Advanced Features:

  • AST analysis tools - ast_py() and ast_grep() for code pattern matching
  • Experimental API - JavaScript/SolveIt communication capabilities

How the Community is Using DialogHelper:

1. Custom Workflow Automation

galopy created a sophisticated system:

  • Built a rules_helper module with project templates
  • Created /app/data/static/rules.mdc with coding standards and templates
  • Uses DialogHelper to automatically generate FastHTML project templates
  • Quote: "I can just ask solveit to lookup the rule using a tool to create a template for FastHTML project using dialoghelper"

2. Educational Module Creation

shuane2253 developed two major DialogHelper modules:

  • Polya Question Module - Implements structured problem-solving prompts

  • Fabric Module - Integrates 220+ built-in prompts from the open-source "fabric" project

  • These are shared as gists that anyone can remix and customize

  • Created a 5-minute tutorial: https://www.loom.com/share/818b99dc6f834927a185099cdf14540d

3. Context Management & Session Continuity

Community members use DialogHelper for:

  • Programmatically adding context to dialogs using add_msg()
  • Converting conversations from other AI tools (Gemini, Claude) into SolveIt format
  • Managing long-running projects by organizing and cleaning up dialog history
  • Batch updating messages for consistency across large conversations

4. Tool Integration & Custom Functions

The community creates custom tools that use DialogHelper to:

  • Manipulate conversation state in real-time
  • Create automated cleanup workflows
  • Build dynamic organization systems
  • Enable AI to modify its own context autonomously

5. Code Analysis & Development

With the new AST-grep integration, users are:

  • Analyzing code patterns across their dialogs
  • Extracting and organizing code blocks systematically
  • Building code documentation from conversation history

Why the Community is Excited:

As hayab_1 noted, DialogHelper represents a paradigm shift from traditional coding to "literate programming" where:

  • Conversations become programmable and manipulable
  • AI can manage its own context and workflow
  • Complex projects can be organized and maintained systematically
  • Knowledge can be preserved and shared efficiently

Jeremy Howard described it as transforming "SolveIt from a chat interface into a fully programmable environment where the AI can modify its own context and manage complex workflows autonomously."

The community sees DialogHelper as enabling true AI collaboration rather than just AI assistance - where both human and AI can programmatically manage and evolve their shared workspace.

SolveIt Updates, gists, and resources

Based on my search through the Discord messages, here are all the key updates, gists, and useful resources that Jeremy and Johno have shared about SolveIt:

Major SolveIt Updates from Jeremy:

Recent Features (September 2025):

  • New Discord Bot: A SolveIt buddy bot that can answer questions (use !ask for regular, !asks for sassy version)
  • Terminal Integration: Each dialog now has a terminal button (🖥️) with shift-t shortcut
  • Persistent URLs: Private SolveIt links now persist across restarts with 🔒 and 🔄 buttons
  • Public Port Access: 🌐 link for port 8000 to run public-facing apps
  • AST-Grep Tool: New code analysis tool added to the platform

Key Keyboard Shortcuts & Features:

  • cmd-shift-period: Create prompt with "." to continue conversation
  • cmd-shift-slash: Same but with thinking mode
  • w: Extract fenced blocks from code outputs
  • ??: Create fenced blocks (e.g., sym?? to grab source code)
  • s: Save & Refresh
  • ⇧s: Stop
  • r: Run all
  • ⇧r: Restart
  • C-Shift-D: Toggle thinking mode

Advanced Features:

  • Multiple Dialog Support: Run multiple dialogs simultaneously
  • Independent Undo History: Each message has its own undo (cmd/ctrl+z)
  • Math Support: KaTeX rendering with USE_KATEX secret
  • Vim Mode: Available with USE_VIM flag
  • File Upload: Upload file/URL button in dialogs

Important Resources & Documentation:

Official Resources:

Video Resources:

Notable Gists from Johno:

Key Tips from Jeremy & Johno:

  1. Edit responses directly rather than asking for corrections
  2. Use tool_info to auto-add main tools to dialogs
  3. Pin messages you don't want in exported notebooks
  4. Copy documentation into note cells for better context
  5. Use private gists for sharing code examples
  6. Multiple kernels can run simultaneously without blocking each other

Technical Integration:

  • FastHTML Integration: Can serve web apps directly from SolveIt
  • Modal GPU Access: Examples of using Modal's GPUs from within SolveIt
  • JavaScript Support: Experimental API for JS-SolveIt communication

This represents the most comprehensive collection of SolveIt updates and resources shared by Jeremy and Johno based on the Discord history!

Github Integration

Based on my search through the Discord messages, I can provide you with comprehensive guidance on how to work with your GitHub repositories in SolveIt for adding new features and debugging issues:

Working with GitHub Repositories in SolveIt

1. Using the Terminal for Git Operations

SolveIt has a built-in terminal that gives you full access to Git commands:

  • Access Terminal: Click the terminal 🖥️ button or use Shift+T keyboard shortcut
  • Git Setup: First configure your Git identity: 
    git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

2. Repository Management Strategies

Option A: Clone Existing Repositories

  • Use the terminal to clone your work repositories directly into SolveIt: 
    git clone https://github.com/yourusername/your-repo.git
cd your-repo

Option B: Initialize New Repository

  • Jeremy Howard recommends running git init in your dialogs folder: 
    git init
git commit -am 'initial commit'

3. Development Workflow

For Adding New Features:

  1. Clone or navigate to your repository in the terminal
  2. Create feature branches using standard Git workflow
  3. Use SolveIt's code execution to test your changes interactively
  4. Leverage the AI assistant to help write, review, and debug code
  5. Commit changes regularly: git commit -am 'feature description'
  6. Push to GitHub: git push origin feature-branch

For Debugging Issues:

  1. Use SolveIt's interactive environment to reproduce bugs
  2. Ask the AI to help analyze error messages and suggest fixes
  3. Test fixes in real-time using the code execution capabilities
  4. Use version control to track what changes fix issues

4. Best Practices from the Community

  • Regular Commits: Jeremy suggests running git commit -am 'message' from time to time to track changes and enable undoing accidental edits
  • Multiple Repositories: You can have multiple repos cloned to your SolveIt instance since it uses a directory-style structure
  • Standard Git Workflow: Use normal Git processes through the terminal - push/pull work exactly as expected
  • Backup Strategy: Push to GitHub for backup and collaboration, but local Git repos work fine for version control

5. Integration Tips

  • Read Repository Content: SolveIt can read URLs from GitHub repos and individual files for context
  • Gist Integration: Export your SolveIt dialogs as GitHub gists for sharing and documentation
  • File Persistence: Files saved in your SolveIt instance persist across dialog sessions
  • Terminal Persistence: The terminal session is tied to your SolveIt instance and maintains your working directory

6. Troubleshooting

If you encounter permission issues:

  • Make sure you've set up your GitHub personal access token properly
  • Configure Git credentials using the terminal
  • Restart your SolveIt instance if needed (Ctrl+Shift+R)

The key advantage is that SolveIt combines the power of an AI assistant with a full development environment, allowing you to get help with code while working directly with your repositories through standard Git workflows.

External context

Based on my search through the Discord discussions, here are the main ways to add external context to SolveIt:

Primary Methods for Adding External Context:

1. Note Cells (Most Common Method)

  • Create note cells at the top of your dialog with relevant documentation, code, or reference material
  • Copy and paste content from external sources (like documentation, llms.txt files, or code) directly into note cells
  • The AI can reference this context throughout the conversation
  • Example from erikgaas: "I copied all the text from https://rogerbinns.github.io/apsw/_sources/example.rst.txt and copied it into a note cell"

2. Using llms.txt Files

  • Copy content from llms.txt files (like from FastLite: https://github.com/AnswerDotAI/fastlite/blob/main/nbs/llms.txt)
  • You can either:
    • Copy the entire llms.txt content into a note cell
    • Copy just the specific documentation you need (more efficient)
    • Let SolveIt's web search tool dynamically search the links in llms.txt (less efficient)

3. URL Reading

  • SolveIt can read URLs directly from GitHub repos and individual files
  • Use the built-in web search integration for dynamic information retrieval
  • The platform converts content to markdown format automatically

4. File Upload

  • Use the file upload button in dialogs to add documents or code files
  • Files persist across dialog sessions within the same SolveIt instance
  • Upload scripts, documentation, or data files as context

5. Copy Documentation Strategy

As recommended by Jeremy & Johno: "Copy documentation into note cells for better context"

Best Practices:

  • Copy specific content rather than relying on dynamic web searches to avoid repeated tool invocations
  • Organize context systematically using note cells at the beginning of your dialog
  • Pin important context messages for persistent reference throughout the session
  • Use gist exports to preserve context-rich dialogs for future sessions

The most effective approach is typically copying the specific documentation or code you need into note cells at the start of your dialog, as this provides immediate context without requiring repeated web searches.

Jeremy's Terminal-Based Version Control Workflow for SolveIt

Jeremy has outlined several approaches for version control in SolveIt, all of which are indeed terminal-based:

Simple Local Version Control (Recommended Starting Point):

  1. Initialize Git in your dialogs folder: Run git init in your dialogs folder
  2. Regular commits: Use git commit -am 'message' from time to time to save checkpoints
  3. Benefits: This gives you full version control and allows you to undo any accidental edits

GitHub Integration Workflow:

  1. Put dialogs in a GitHub repository: Place dialogs you want to work on in multiple places within a GitHub repo
  2. Use terminal or dialog bash commands: Push/pull using standard Git commands in the usual way
  3. Access via terminal button: Use the terminal 🖥️ button in each dialog (shortcut: shift-t) which opens a terminal at the current dialog's folder

Key Points Jeremy Emphasized:

  • You don't necessarily need GitHub at all - local Git is sufficient for version control
  • GitHub is only needed if you want extra backup, collaboration with others, or access from other machines
  • Terminal integration: There's now a terminal button in each dialog that opens at the dialog's folder
  • Persistence: .gitconfig should be persistent for global Git configuration

Additional Terminal Features:

  • Terminal shortcut: shift-t opens terminal in current dialog folder
  • Command shortcuts: cmd-shift-r in the terminal for additional functionality
  • Currently only one terminal runs at a time (they mentioned plans to improve this)

More tool integration and functions in SolveIt

The ACTUAL Correct Way to Define SolveIt Functions

Proper Function Structure:

def calculate_area(
  length: float, # Length of the rectangle in units
  width: float   # Width of the rectangle in units
) -> float:  # The area as a float
    "Calculate the area of a rectangle."
    return length * width

Key Points (that I apparently needed beaten into my digital skull):

  1. Type annotations: Required for all parameters AND return type
  2. Docments syntax: Comments go RIGHT AFTER the parameter on the same line
  3. Simple docstring: Just a brief description in quotes
  4. Return type documentation: Comment after the -> return type annotation
  5. Concise and clean: No verbose docstring blocks, no extra fluff

To Make It Available as a Tool:

&`calculate_area`

This workflow leverages SolveIt's built-in terminal functionality to provide standard Git-based version control directly within the SolveIt environment.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment