Month: May 2025

My Journey with the Contemplation Machine: A Tool for Mindful Reflection

Summary

Have you ever wished for a tool that helps you deepen your understanding of important concepts through focused contemplation? What if you could create personalized guided meditations tailored to your specific needs? In this article, I share my experience developing the /Contemplation Machine, an open-source app that fills a unique gap in the meditation app market. I’ll explain what contemplation is, how this tool works, and provide practical installation guidance – all from my journey of creating this project in just four days using modern development techniques.

Introduction

2025-05-23_10-22-32_2025-05-22_20-08-36.png

Figure 1: Youtube Video introducing the Contemplation Machine

A few weeks ago, I released a video on YouTube about my latest open-source project, the Contemplation Machine. I built this tool because I noticed something missing in the meditation app landscape – while there are countless meditation apps available, none specifically focus on helping users build their own structured contemplations. Today, I want to share the story behind this project and show you how it can enhance your mindfulness practice.

What is contemplation?

Contemplation is often misunderstood or confused with meditation, but it’s actually a distinct practice with its own benefits. In Tibetan Buddhism, there’s a threefold training approach: study, contemplation, and meditation. During study, we actively use our minds to learn new concepts. In contemplation, we examine these concepts more deeply, allowing our minds to rest on a specific theme for an extended period. Finally, meditation helps us habituate our minds to a particular perspective.

2025-05-23_10-41-33_cinematicphotoApeacefulper_39143729.png

Figure 2: Illustration created with DiffutionBee on MacBook Pro M2

What I find particularly valuable about contemplation is how it bridges the gap between intellectual understanding and experiential wisdom. While contemplation is traditionally used in spiritual contexts, I’ve found it equally powerful in professional and everyday settings. This realization was my primary motivation for creating the Contemplation Machine.

What is the Contemplation Machine?

The Contemplation Machine is a meditation app with a specific focus on contemplation. Unlike standard meditation apps that provide pre-recorded sessions, my tool allows users to build their own contemplations and meditations from scratch. When I analyzed the market, I couldn’t find anything similar that gave users this level of creative control over their practice.

2025-05-23_10-25-31_2025-05-23_10-25-19.png

Figure 3: Cartoon created with Dall-E 3

The app works by taking your written instructions – simple phrases or prompts that you want to contemplate – and distributing them evenly throughout your chosen meditation duration. It then plays these instructions back to you using text-to-speech technology, creating a completely personalized guided experience.

How to use it

Using the Contemplation Machine is straightforward. When you first install it, several pre-built contemplations are available to try immediately. However, the real power comes from creating your own.

To create a contemplation, you simply write a series of instructions, with each instruction on a single line in the text window. As a basis you can choose spiritual texts, or methods for personal development. For example, I demonstrated using the Four Brahmaviharas (loving-kindness, compassion, sympathetic joy, and equanimity) as a contemplation framework in the video. Another good example is practicing WOOP, a science-backed mental contrasting technique developed by psychologist Gabriele Oettingen that transforms wishes into achievable goals through four key steps: Wish, Outcome, Obstacle, and Plan.

Once your instructions are ready, you save them as an instruction file. Then, on the Configure page, you select your instruction file, choose a voice provider (browser-internal, OpenAI, or Eleven Labs), set the duration, and optionally add bell sounds to mark the beginning or end. After saving your configuration as a preset, you’re ready to begin your practice with a single click.

Using voice guidance, the quality of the voice is critical. According to my experience, Elevenlabs delivers the best quality, however at a premium price. The good news is that the Contemplation Machine only requests the Text-To-Speech API once for every instruction and caches the sound file.

How to install it

Installing the Contemplation Machine is surprisingly simple. The easiest method is using Docker, which is how I typically run it myself. Here’s how:

  1. Install Docker Desktop on your computer
  2. Search for the Contemplation Machine image
  3. Run it, specifying a port (like 8010)
  4. Open your browser and navigate to localhost:8010

For my personal setup, I run it on an old MacBook that serves as my home server. Using Tailscale, I’ve created a network that allows me to access my Contemplation Machine from any device, anywhere. This deployment architecture – a home server running Docker with Tailscale networking – is what I recommend for the best experience.

2025-05-23_10-31-29_2025-05-23_10-28-52.png

Figure 4: Deployment Architecture Diagram

An interesting side note: I developed the entire app in just four days using GitHub Copilot in Agent Mode. The app uses Node.js for the backend and React for the frontend, making it a fascinating case study in modern software development.

Conclusion

Creating the Contemplation Machine has deepened my own practice while providing a valuable tool for others. What began as a personal project to enhance my contemplation practice has evolved into something I’m proud to share with the community. The process of building it was as contemplative as using it!

I find myself using it almost daily now, creating new contemplations for both spiritual practice and professional development. There’s something powerful about hearing your own carefully crafted words played back to you, which makes it easy to include new content in your daily meditation routine.

AI-Supported Development: The Unfair Race That’s Changing Everything

A Journey into GitHub Copilot Agent and the Creation of the Contemplation Machine

What began as a simple test of GitHub Copilot’s new agent mode quickly transformed into a four-day development sprint that completely changed my perspective on software development. In this article, I’ll share my experience building the “Contemplation Machine” – a meditation app I’ve always wanted – and how AI-assisted development created a workflow that feels almost unfair in its efficiency. Can professional developers afford to ignore these tools? What happens when AI doesn’t just suggest code but actively participates in writing it? These questions became central to my journey as the line between human and AI contributions began to blur.

Introduction

“Software development without AI support is like trying to overtake a car on a bicycle.”

This realization hit me forcefully when I recently decided to test GitHub Copilot’s new agent mode. What started as curiosity quickly evolved into an intensive four-day development sprint that yielded results I couldn’t have achieved alone in such a timeframe.

The experience wasn’t just about producing code faster. It fundamentally altered how I approach software development. The synergy between my domain knowledge and the agent’s coding capabilities created a workflow that felt almost unfairly efficient compared to traditional development methods.

What is the Contemplation Machine?

The Contemplation Machine is a meditation app I’ve always wanted to have – a personal project that had been sitting in my mental backlog for months. It’s designed to provide guided meditation sessions with customizable durations, themes, and custom instructions.

2025-05-07_17-40-43_2025-05-07_17-40-34.png

Figure 1: Cartoon illustrating the Contemplation Machine

When I started the project, I wasn’t actually planning to complete it. I simply wanted to test GitHub Copilot’s new agent capabilities on something practical. But within just a few hours, the results were so impressive that I decided to commit fully to developing a complete open-source version.

What makes this app special isn’t just its functionality, but the process through which it came to be. Almost every line of code bears the fingerprints of both human and AI collaboration – a development approach that would have been science fiction just a few years ago.

The Development of the Contemplation Machine

My development process with GitHub Copilot Agent was dramatically different from my usual workflow. I started by presenting my project idea to the LLM and asking which approach, technology, and architecture it recommended. This initial consultation shaped the entire project, despite my limited experience with some of the recommended frameworks.

For each release, I created a brief description of requirements and asked the agent to create a concept and implementation plan. After reviewing and adjusting this document, we typically broke implementation into xthree or four phases. I then instructed the agent to implement each phase sequentially.

What amazed me most was how the agent could handle these phases almost independently, making coordinated changes across multiple files. By the end, I often just needed to verify functionality in the finished application.

I primarily worked with Anthropic’s Claude 3.7 Sonnet model in GitHub Copilot, which proved to be the most powerful and usable among the available options. The quality difference between models was substantial, with Anthropic’s offerings consistently delivering the most valuable assistance.

2025-05-07_17-37-16_2025-05-07_17-33-40.png

Figure 2: Development of the Contemplation Machine in VSCode with GitHub Copilots Agent Mode.

The Challenges and Solutions

Despite the impressive capabilities, this development approach wasn’t without significant challenges. One major issue was interference capacity – the responsiveness of the large language model. I frequently encountered long waiting times and sometimes prompts would be cancelled entirely, requiring repetition. This unpredictability disrupted my development flow, often forcing me to take breaks until response times improved.

Another substantial challenge was managing complexity. I initially started with a more ambitious program model that included complete user administration with authentication. While the agent generated impressive code, once the complexity exceeded a certain threshold, it began introducing new errors with each iteration cycle. Eventually, I couldn’t stabilize the codebase and had to discard everything and start over.

From this experience, I learned several important strategies:

  • Keep changes small and focused
  • Commit frequently
  • Establish a clear release model for reverting problematic changes
  • Push back against the agent’s tendency to propose overly complex solutions
  • Explicitly request simplification when needed

The Significance for the IT Industry

Working with GitHub Copilot Agent forced me to confront an uncomfortable truth: the agent consistently generated better code faster than I could write it myself. During response delays, I found myself reluctant to continue coding manually because the quality and speed differential was so stark.

This dynamic is what I mean by “the unfair race.” It’s like trying to overtake a car while riding a bicycle, or navigating with a paper map when others have GPS. Professionals who embrace these tools gain an almost unfair advantage in productivity and capability.

The implications for the IT industry are profound. Developers who resist AI assistants may find themselves increasingly outpaced by those who embrace them. The competitive gap isn’t marginal – it’s transformative. As these tools continue to improve, this disparity will only widen.

At the same time, the role of the developer is evolving. Technical expertise remains essential, but conceptual thinking, architectural planning, and effective AI collaboration are becoming equally critical skills. The most successful developers won’t be those who write the most code, but those who can orchestrate AI capabilities to achieve ambitious goals.

Conclusion

My journey developing the Contemplation Machine with GitHub Copilot Agent has fundamentally changed how I view software development. What began as a simple test revealed a new paradigm that combines human creativity with AI execution in ways that feel almost magical at times.

Despite the challenges and limitations, the benefits are undeniable. I accomplished in four days what might have taken weeks using traditional methods, especially considering my limited familiarity with some of the technologies involved.

The experience has convinced me that AI-assisted development isn’t just an incremental improvement – it’s a step-change that’s reshaping our industry. The question isn’t whether to adopt these tools, but how quickly we can adapt our workflows and mental models to maximize their potential.

For anyone still hesitating, I can only offer this: the race has already begun, and those on bicycles won’t catch those in cars, no matter how fast they pedal.

Key Takeaways and Resources

  • GitHub Copilot Agent provides code editing capabilities that go beyond simple suggestions
  • Model selection matters: Anthropic’s Claude models consistently outperformed others
  • Complexity management is essential – break projects into manageable phases
  • Frequent commits and a solid release model help manage the occasional instability
  • Conceptual direction should remain human-driven, with requests for simplification when needed
  • Developer productivity increases dramatically with effective AI collaboration