How to stick with your projects, even when they're janky

SUMMARY

Jeaye Wilkerson, creator of jank—a native Clojure dialect on LLVM—discusses sustaining long-term projects through momentum, focus, community, prioritization, and grounded dreaming, drawing from a decade of development experience.

STATEMENTS

Thirteen years ago, during a rant about functional testing in game development, Jeaye's team lead labeled him as someone who would "never ship," prompting deep reflection on perfectionism and completion.
Perfectionism drives enjoyment in designing ideal systems but hinders actual shipping, leading Jeaye to track a personal "manifest" of started and finished projects over 13 years.
Clear project goals are essential for defining what "sticking with" means, whether for learning, fame, or exploration, and goals can evolve with progress.
Momentum is the key to sustaining projects, built and maintained through focused practices tailored to one's mindset.
Avoiding side projects prevents chasing "new project energy," which disrupts momentum and leads to costly rewrites in long-term efforts.
Rewrites build design taste but undermine shipping goals; sticking with imperfect designs is crucial for usable software.
Building an open-source community requires accepting shared contributions, using tickets as design docs, and fostering positive, encouraging interactions despite personal dislikes like code review.
Code is a lossy encoding of plans, making re-entry into projects challenging; clear documentation bridges knowledge gaps for contributors.
Cultural shifts over 2,500 years transformed artists from anonymous communal creators to celebrated individual geniuses, influencing modern desires for sole authorship in open source.
Prioritization means tackling the most important tasks aligned with goals, breaking them into tiny, finishable pieces to combat fear of failure.
Dreams set direction but must remain grounded in reality; unchecked dreaming leads to satiation without action, incompatibility with facts, or inevitable disappointment.

IDEAS

Tracking a "manifest" of all started projects, books, and classes over years reveals patterns in perfectionism and completion rates.
Even "tinkering" without explicit goals counts as a goal: pure exploration and fun, which shapes how long one sticks with a project.
Side project ideas should be logged but not pursued, channeling "new project energy" into features of the main project to avoid momentum loss.
Reading code is inherently difficult due to its lossy nature, separating essential plans from incidental complexity, much like navigating in the dark.
Encouraging community contributions starts with positive responses to issues, guiding newcomers to specific code spots, often leading to pull requests.
The emotional pull to code everything oneself stems from a 2,500-year cultural evolution romanticizing individual genius over collaborative workshops.
Open-source teams should emulate historical artist workshops: apprentices for basics, assistants for core work under supervision, and expert collaborators for vision.
Fear of important tasks arises from attached dreams; breaking them into micro-tasks like including C++ headers creates small wins that build to breakthroughs.
Dreams can satiate like a dopamine hit from sharing ideas, detach into unrealizable fantasies, or make reality feel inadequate, mirroring Kafka's incompatible personal aspirations.
Enthusiasm acts as a depletable resource in open-source maintenance; balancing "earning" tasks like cleanup with "burning" ones prevents burnout.

INSIGHTS

Perfectionism's allure in design must yield to shipping realities, as sustained momentum from small completions outweighs ideal but unfinished visions.
Side pursuits erode project mass without proportional gains, turning rewrites into addictive escapes that perpetuate incompletion.
Community building transforms solo burdens into shared progress, but requires embracing code-reading aversion through structured guidance like ticket-as-design-docs.
Cultural myths of solitary genius hinder open-source health; reverting to workshop models fosters apprenticeships that scale expertise without ego-driven isolation.
Prioritizing via goal-aligned micro-tasks demystifies daunting features, turning unprecedented innovations like C++ interop into achievable sequences of relief.
Grounded dreaming aligns aspirations with reality, preventing emotional traps like Kafka's, ensuring direction without the paralysis of unattainable ideals.

QUOTES

"And that is why you will never ship."
"If you chase that new project energy... it leads to rewrites."
"Code is not the complete picture... taking a plan and turning it into code is a lossy encoding."
"Isn't it cool? Isn't it so cool that that feeling that you have of I want to be the one to implement this is a product of 2500 years of cultural shift."
"Enthusiasm is a depletable resource."

HABITS

Maintaining a "manifest" list tracking every started project, book, and class, updating it annually to monitor completion rates.
Logging hundreds of side project ideas in a separate file without acting on them, reserving energy for the main project.
Using tickets as design documents to outline feature rationale, user experience, and implementation for community alignment.
Breaking large tasks into tiny, testable pieces—like including C++ headers—committing and pushing each for immediate relief.
Scheduling "easy days" like Fridays for cathartic cleanup of nagging technical debt to replenish enthusiasm and avoid burnout.

FACTS

Jank is a native Clojure dialect on LLVM with seamless C++ interop, unprecedented in Lisps and mainstream languages.
Over 10 years, Jeaye has worked on jank, evolving it from non-Clojure origins while securing sponsorships for sustainability.
In Baroque-era artist workshops, like Rembrandt's, dozens collaborated on single paintings under one expert's supervision, despite individual attribution.
Franz Kafka and Felice Bauer exchanged hundreds of letters over five years, meeting rarely, leading to two broken engagements due to conflicting dreams.
From archaic Greece to the Romantic period, art shifted from anonymous communal works to individualized expressions of tortured or divine genius.

REFERENCES

Book: Legend, Myth, and Magic in the Image of the Artist (1934, art historians on 2,500 years of artist perception).
Talk: Peter Telsanis's recent open-source maintenance presentation on enthusiasm as a depletable resource.
Quote: Henry David Thoreau's "If you have built castles in the air, your work need not be lost. That is where they should be. Now put foundations under them."
Project: Jank (native Clojure dialect on LLVM with C++ interop).
Tool: Nix shell and build system for packaging improvements.
Historical example: Sayilos-signed Greek pottery as an exceptional early artist attribution.

HOW TO APPLY

Identify and confront your project's goals explicitly, whether learning a technology or building for fame, then reassess as they evolve to redefine "sticking with it."
Avoid side projects by logging ideas separately and channeling fresh energy into main project features, preventing momentum loss and rewrite temptations.
Foster community by responding encouragingly to issues—agree, suggest GitHub tickets, point to specific code files—and guide post-merge with next-task suggestions to sustain involvement.
Prioritize by aligning tasks with goals, breaking enormous ones like C++ interop into micro-steps (e.g., header inclusion with tests), committing each for quick wins.
Maintain enthusiasm by alternating hard tasks with easy, restorative ones like code cleanup on designated days, treating it as a reserve to prevent burnout.

ONE-SENTENCE TAKEAWAY

Build and sustain project momentum through focused goals, community collaboration, micro-prioritization, grounded dreams, and enthusiasm reserves.

RECOMMENDATIONS

Log but defer side ideas to preserve main project inertia, redirecting novelty into enhancements.
Use tickets as collaborative design docs to minimize code-review surprises and bridge knowledge gaps.
Embrace workshop-style open source with apprentices and assistants to distribute load without losing vision.
Break intimidating tasks into testable micro-units, celebrating each commit to conquer fear of big failures.
Schedule regular "easy days" for low-stakes wins like debt cleanup, safeguarding against enthusiasm depletion.

MEMO

In the high-stakes world of software development, where grand visions often collide with the grind of execution, Jeaye Wilkerson has spent over a decade wrestling with imperfection. As the creator of jank—a pioneering native dialect of Clojure built on LLVM with seamless C++ integration—Wilkerson knows the lure of starting fresh all too well. His journey began 13 years ago in a San Francisco bar, amid a heated rant on functional testing for games, when his team lead quipped, "And that is why you will never ship." The words stung, exposing a perfectionist's paradox: delight in crafting ideal systems, dread in delivering them.

Wilkerson's response was methodical. He began maintaining a "manifest," a ledger of every project, book, and class he started—and whether he finished them. This ritual revealed a pattern: enthusiasm for green-field exploration, but faltering momentum in the long haul. For jank, aimed at bridging Clojure developers to native performance while luring C++ experts to functional paradigms, sticking it out meant confronting goals head-on. Whether prototyping OpenGL for learning or chasing open-source stardom, he argues, undefined aims doom efforts. Goals evolve, but ignoring them invites the "never ship" label.

The antidote, Wilkerson insists, is momentum—built by ruthless focus. No side projects, even as a decade's file of wild ideas (like a GitHub-commit-based RPG) tempts him. Chasing "new project energy" rebuilds excitement at the cost of reaccelerating the "mass" of existing code, often spiraling into rewrites. While rewrites hone design taste—say, iterating a JSON parser in Clojure—they sabotage shipping. Instead, embrace the janky: tolerate flaws to let users engage. For open-source sustainability, this extends to community. Wilkerson admits his aversion to reading code, a "lossy encoding" of broader plans riddled with incidental complexity. Yet, by treating tickets as design docs—detailing why, how, and what—contributors align without surprise.

History offers a mirror. In a talk laced with cultural critique, Wilkerson cites Legend, Myth, and Magic in the Image of the Artist, tracing 2,500 years from anonymous Greek pottery to Romantic-era solo geniuses like tortured Kafka, whose dream of literary devotion clashed with marital ideals, yielding only disappointment. Modern open source, he says, romanticizes lone creators but thrives on workshops: apprentices grinding basics, assistants painting under expert eyes. For jank, this meant encouraging issue-raisers with specifics—"Jump to this function"—sparking pull requests, like one contributor's Nix shell upgrade leading to packaging pursuits.

Prioritization anchors it all. Aligned with goals, daunting feats like unprecedented Lisp-C++ interop fracture into bites: include headers, test, commit, exhale. Dreams set direction—zoom out to the forest—but stay grounded; unchecked, they satiate like shared boasts or detach into impossibilities. Enthusiasm, a depletable fuel per recent talks, demands easy days: Fridays for cathartic cleanups of nagging debt. In closing, Wilkerson channels Thoreau: Build air castles, then found them solidly. For developers adrift in jank, this philosophy isn't just survival—it's a blueprint for flourishing amid the mess.