How I Used AI to Develop 10 Obsidian Plugins
A Journey of Failures, Lessons, and Breakthroughs
Over the past two years, I have harnessed the power of AI tools to develop 10 Obsidian plugins—a journey filled with frustration, learning, and ultimate satisfaction. Despite having little knowledge of TypeScript at the start, AI transformed the way I approach coding, enabling me to create solutions that address long-standing gaps in my workflow. This journey not only taught me valuable lessons about programming in TypeScript but also revealed the true potential of collaborating with AI.
The Initial Spark and Early Aspirations
My journey began when I found that, while taking notes at work, I constantly struggled with managing task statuses and attaching accurate timestamps. I initially believed that requesting new features from existing plugins would be the easiest path. Although some feature requests were implemented quickly, many remained on the back burner for a year or more. As an end-user with pressing needs, I realized that waiting was not an option.
The idea was simple: if I could have a tool that effortlessly changed task statuses (incomplete, complete, canceled, bookmarked, etc.) and automatically recorded when tasks were created or completed, my note-taking process would finally be streamlined. This insight drove me to explore AI-assisted development.
The First Breakthrough: Task Marker
Armed with the AI IDE tool Cursor, I dove into modifying an existing plugin known as Task Collector. By studying its code, I leveraged AI to add functionalities that aligned perfectly with my requirements. The result was Task Marker a plugin that quickly let me change task statuses and append timestamps—a solution that I now use every day. Despite the initial shock of seeing a first version emerge at record speed, I knew this was only the beginning.
I interacted extensively with Cursor—asking targeted questions about which functions to adjust and where to insert new code. Whenever I encountered errors, I would share the failure details with both Cursor and ChatGPT. Although early AI suggestions were sometimes wildly off the mark, they played a crucial role as an assistant in troubleshooting and iterating over the code.
Encountering Setbacks: Todoist Sync and Canvas Challenges
After my success with Task Marker, I was inspired to create a Todoist sync plugin. The goal was to effortlessly create tasks in Obsidian and have them synchronized with Todoist, complete with embedded note links. Unfortunately, the existing Todoist Sync plugin, while functional, could not fulfill my specific need of inserting note links as clickable URLs in the task descriptions.
Determined to solve this, I embarked on developing my own version. However, the complexity of the existing codebase combined with my limited TypeScript skills and the constraints of the Cursor AI model made it clear that this project was beyond a quick fix. In the end, the Todoist sync project was temporarily shelved.
Similarly, I attempted to create a plugin initially named Link to Canvas to send note and block links to a Canvas file. Another idea was to develop a plugin to automatically adjust the sizes of text boxes on Canvas files—a feature that would replace the tedious manual adjustments. Both of these ventures encountered significant hurdles. The AI-generated code sometimes managed to copy text box sizes but failed to persist these changes upon reopening the Canvas file. Despite providing multiple error reports, including detailed console messages and code snippets, these plugins did not materialize as expected. Each failure, though disheartening at the moment, became a valuable learning experience.
Transitioning to a More Powerful AI IDE
The turning point came when I discovered WindSurf, a new AI IDE with extended capabilities at the time. With WindSurf, I was able to develop subsequent plugins at a much faster pace. In fact, after my first few plugins (Task Marker, Copy Metadata, and Timestamp Link) built with Cursor, every new project—from Link Maintainer, URI Converter, Todoist Context Bridge, File Title Updater, Folder Navigator, and Send to Canvas to Canvas Format Brush—was largely powered by WindSurf.
WindSurf enabled me to generate a usable prototype of a simple plugin within an hour. Even more complex functionalities, such as those in the Todoist Context Bridge plugin, were built in just two or three hours. Beyond generating the code from scratch, WindSurf also helped streamline the entire development workflow, automating tasks like publishing and documentation.
The Art of Communicating with AI
A pivotal lesson I learned early on was the importance of clear, detailed communication with AI. Vague prompts often resulted in solutions that diverged from my true intentions. I discovered that the more details I provided—the precise functions needed, error logs, snippets of working code from similar plugins, and even suggestions to use official APIs over fabricated ones—the better the AI could assist me.
For instance, when developing the Send to Canvas plugin, my original prompt was too simplistic: “I want to send note links to Canvas.” The AI’s response missed critical details, such as verifying whether a block ID already existed and creating one if it did not. After I refined my prompt to include these specific requirements, the AI-generated solution aligned much more closely with my vision.
Additionally, I learned the value of iterative improvement. No plugin was perfect from the start. I often had to engage in multiple rounds of Q&A with the AI, gradually refining the code by addressing issues one by one—be it misaligned UI elements, non-persistent formatting, or unwieldy, bloated code. Sometimes, restarting a fresh session with the AI, free from the baggage of previous errors, was the key to unlocking a new perspective.
Balancing Ambition with Practicality
One recurring challenge was managing expectations. At times, I found myself being overly ambitious—requesting the AI to implement several features in one go. This “all-or-nothing” approach often resulted in partial solutions where some functionalities were excellent while others were lacking. I learned that it is more effective to focus on the core functionality first, then gradually add enhancements. For example, in the Send to Canvas project, the initial focus was on sending basic text blocks using block links and embeds. Only after ensuring that this fundamental capability worked well did I iterate further to include note links and embeds.
Improving My Workflow and Achieving Efficiency
With each successful plugin, my personal productivity and workflow improved dramatically.
- Todoist Context Bridge revolutionized my task management. Previously, creating a task required copying an external URI link, opening Todoist, pasting the link, and then manually setting deadlines and priorities. Now, I can create a task directly within Obsidian and send it to Todoist with a single command, with attributes such as due date, priority, and project automatically recognized.
- The Canvas plugins Canvas Format Brush and Send to Canvas have eliminated the tedious manual adjustments I used to make on Canvas files. With these tools, I can copy formatting or send tasks with a couple of clicks, significantly boosting my efficiency.
Not only have these plugins automated routine tasks, but they have also provided a sense of satisfaction and accomplishment. Sharing them with the community has added an extra layer of motivation to continue innovating.
Reflections on the Evolution of AI Models
Throughout this journey, I witnessed firsthand how rapidly AI tools are evolving. I started with early models such as GPT-3.5 and GPT-4, experiencing their limitations in handling complex code and understanding nuanced requirements. Now, with tools like WindSurf integrated with Claude 3.7 Sonnet—which even features “Thinking” capabilities similar to OpenAI o3’s reasoning—the need for multiple interactions has diminished. The AI now understands my commands with far fewer iterations, reflecting a significant leap in both its code-generation abilities and its understanding of human instructions.
This progression raises important questions about the future role of developers. While some fear that AI might eventually replace human coders, I believe that the true value of a developer lies in the ability to conceptualize and communicate ideas—areas where AI still requires our guidance. Embracing AI as a collaborator rather than a replacement is the key to unlocking even greater productivity.
Looking Ahead: The Future of AI-Assisted Development
As I continue to refine and expand my suite of plugins, I remain excited about the future. There are still challenges—such as automatically syncing the completion status between Todoist and Obsidian—but each obstacle is an opportunity to learn and iterate. With ongoing improvements in AI models and development environments, the potential for innovation is boundless.
I am convinced that the most effective approach is to remain clear in our demands, iteratively refine our prompts, and always provide comprehensive supporting materials. This strategy not only ensures that AI tools work to our advantage but also reduces the likelihood of miscommunication and inefficient solutions.
Final Thoughts
The journey from a frustrated note-taker to a developer of 10 Obsidian plugins has been transformative. Through failures and breakthroughs alike, I have learned that clarity, patience, and a willingness to iterate are essential when working with AI. The fusion of human creativity with machine efficiency has redefined my workflow, proving that collaboration with AI is not just a temporary trend—it is the future of software development.
I hope that by sharing my experiences, other developers will be encouraged to experiment with AI tools. Embrace the failures, celebrate the breakthroughs, and remember that every misstep is just another stepping stone toward innovation. Together, we are not only building plugins; we are shaping the future of how technology can serve our creative and professional lives.