Posts Tagged ‘SpecDrivenDevelopment’
[VoxxedDaysTicino2026] Technical Enshittification: Why Everything in IT is Horrible Right Now and How to Fix It
Lecturer
Baruch Sadogursky is the Head of Developer Relations at TuxCare, with a distinguished career in Java and DevOps ecosystems. A Java Champion and Microsoft MVP for AI, he has authored books on these topics and is known for his candid analyses of industry trends.
Abstract
This article examines Baruch Sadogursky’s critique of technical enshittification, where software platforms degrade user experiences after gaining dominance. It explores the underlying causes, such as excessive complexity and bloat, and proposes remedies through AI, smart tooling, and refined workflows. By analyzing real-world examples and systemic issues, the discussion highlights methodologies for restoring efficiency and innovation in IT.
The Phenomenon of Enshittification in Technology
Baruch Sadogursky introduces the concept of technical enshittification as an extension of Cory Doctorow’s idea, where platforms initially attract users but subsequently exploit them at the expense of quality. In software, this manifests as bloated applications, sluggish performance, and accumulating bugs that erode reliability. He illustrates this with examples like operating systems losing files or password managers suffering repeated breaches, underscoring how such degradation is not isolated but systemic. The contexts reveal that this trend stems from economic pressures favoring monetization over maintenance, leading to innovation that often amounts to superficial changes rather than substantive improvements. The implications are profound, as they diminish developer productivity and user satisfaction, fostering a cycle of frustration in the industry.
Systemic Causes and Their Interconnections
The talk delves into how complexity has become an obstacle course in software development, with layers of tools, approvals, and abstractions slowing progress. Baruch points to attention fragmentation, where developers spend minimal time coding—around 52 minutes daily—due to distractions like meetings and context switching. He references studies showing it takes 25 minutes to refocus after interruptions, amplifying the toll of lengthy builds or code reviews. Organizational habits, such as frequent reorgs, further destroy shared knowledge, while technical debt accumulates from unrefactored legacies. Bloat exacerbates vulnerabilities, as more code lines create more attack surfaces, evidenced by rising malicious packages in repositories. The contexts connect these to broader industry dynamics, where rapid feature additions outpace quality controls. The implications include stalled innovation and heightened risks, as teams grapple with outdated contexts rather than advancing core functionalities.
AI as a Double-Edged Sword in Development
Baruch views AI as a catalyst that accelerates code generation but risks compounding technical debt through unvetted outputs. While it promises faster features, it often introduces bugs and vulnerabilities, as seen in Java’s poor performance on AI security benchmarks. He critiques the “credit card” mindset, where AI enables unchecked experimentation, leading to more complexity. However, he advocates for its responsible use in context engineering—compressing knowledge for relevance and expanding it thoughtfully. Spec-driven development emerges as a safeguard, where high-level specs guide agents, ensuring traceability. The contexts highlight the need for integrity chains to verify AI-generated code against intentions. The implications suggest AI can revitalize workflows if paired with human oversight, but without it, it perpetuates enshittification.
Organizational Reforms and Workflow Optimizations
To combat these issues, Baruch recommends streamlining processes to minimize distractions and preserve context. Agile principles, when applied purely, encourage reactive planning over rigid foresight, allowing small bets to test assumptions iteratively. DevOps practices, like automation and “you build it, you run it,” offload context to systems, reducing manual toil. Management should focus on documentation of decisions and protecting focus time. The contexts draw from attention research, showing how interruptions fragment productivity. The implications include enhanced efficiency, where teams reclaim coding time and foster cultures of continuous improvement.
Reclaiming Joy and Progress in Software Engineering
In conclusion, Baruch urges embracing these reforms to restore the joy of building software. By prioritizing context preservation and leveraging AI judiciously, organizations can escape enshittification’s grip. The talk serves as a call to action, reminding developers they are not alone in facing these challenges and that proactive changes can lead to meaningful progress.
Links:
[VoxxedDaysTicino2026] Backlog.md: The Simplest Project Management Tool for the AI Era
Lecturer
Alex Gavrilescu is a full-stack developer with extensive experience in .NET and Vue.js technologies. He has been actively involved in software development for many years and has shifted his focus toward artificial intelligence since last year. Alex developed Backlog.md as a side project starting from the end of May 2025, while maintaining a full-time role in the casino industry. He shares insights through blog articles on platforms like LinkedIn and X (formerly Twitter). Relevant links include his LinkedIn profile (https://www.linkedin.com/in/alex-gavrilescu/) and X account (https://x.com/alexgavrilescu).
Abstract
This article examines Alex Gavrilescu’s presentation on his journey in AI-assisted software development and the creation of Backlog.md, a terminal-based project management tool designed to enhance predictability and structure in workflows involving AI agents. Drawing from personal experiences, the discussion analyzes the evolution from unstructured prompting to a systematic approach, emphasizing task decomposition, context management, and delegation modes. It explores the tool’s features, limitations, and implications for spec-driven AI development, highlighting how such methodologies foster deterministic outcomes in non-deterministic AI environments.
Context of AI Integration in Development Workflows
In the evolving landscape of software engineering, the integration of artificial intelligence agents has transformed traditional practices. Alex begins by contextualizing his experiences, noting the shift from basic code completions in integrated development environments (IDEs) like Visual Studio’s IntelliSense, which relied on simple machine learning or pattern matching, to more advanced tools. The advent of models like ChatGPT allowed developers to query and incorporate code snippets, reducing friction but still requiring manual transfers.
The introduction of GitHub Copilot marked a significant advancement, embedding AI directly into IDEs for contextual queries and modifications. However, the true leap came with agent modes, where AI operates in a loop, utilizing tools and gathering context autonomously until task completion. Alex distinguishes between “steer mode,” where developers iteratively guide AI through prompts and approvals, and “delegate mode,” where comprehensive instructions are provided upfront for independent execution. His focus leans toward delegation, aiming for reliable outcomes without constant intervention.
This context is crucial as AI models are inherently non-deterministic, yielding varied results from identical prompts. Alex draws parallels to human collaboration, where structured information—clarifying the “why,” “what,” and “how”—ensures success. He references practices like Gherkin scenarios (given-when-then) but simplifies them to acceptance criteria and definitions of done, adapting them for AI efficiency. Early challenges, such as limited context windows in models like those from May 2025, necessitated task breakdown to avoid information loss during compaction.
The implications are profound: unstructured AI use often leads to abandonment, as complexity escalates failure rates. Alex classifies developers into categories like “vibe coders” (improvisational prompting without code review) and “AI product managers” (structured delegation with final reviews), illustrating how his journey from near-abandonment to 95% success stemmed from imposing structure.
Development and Features of Backlog.md
Backlog.md emerged as Alex’s solution to the limitations of manual task structuring. Initially, he created tasks in Markdown files, logging them in Git repositories for sharing and history. This allowed referencing between tasks, scoping to prevent derailment, and assigning tasks to specialized agents (e.g., Opus for UI, Codex for backend). By avoiding database or API dependencies, agents could directly read files, enhancing efficiency.
The tool formalizes this into a command-line interface (CLI) resembling Git commands: backlog task create, edit, list. Tasks are stored as Markdown with a front-matter section for metadata (title, ID, dependencies, status). Sections include “why” for problem context, acceptance criteria with checkboxes for self-verification, implementation plans generated by agents, and notes/summaries for pull request descriptions.
Backlog.md supports subtasks, dependencies (e.g., “relates to” or “blocked by”), and a web interface for easier editing, including rich text and dark mode. It operates offline, uses Git for synchronization across branches, and avoids conflicts by leveraging repository permissions for security. Notably, 99% of its code was AI-generated, with Alex reviewing initial tasks, demonstrating the tool’s recursive utility.
Limitations include no direct task initiation from the interface, self-hosting requirements, single-repo support, experimental documentation/decisions sections, and absent integrations like GitHub Issues or Jira. As a solo side project, it lacks production-grade support, but welcomes community contributions via issues or pull requests.
In practice, Alex showcases Backlog.md in a live demo for spec-driven development. Starting with a product requirements document (PRD) generated by an agent like Claude, tasks are decomposed. Implementation plans are reviewed per task to adapt to changes, ensuring accuracy. Sub-agents orchestrate parallel planning, with human checkpoints at description, plan, and code stages.
Methodological Implications for Spec-Driven AI Development
Spec-driven AI development, as outlined, requires clear intent expression before execution. Backlog.md facilitates this by breaking projects into manageable tasks, delegating to agents for research, planning, and coding. A feedback loop refines agent instructions, specs, and processes.
Alex’s workflow begins with PRD creation, followed by task decomposition adhering to Backlog.md guidelines. Agents generate plans only upon task start, preventing obsolescence. For a task-scheduling feature, he demonstrates PRD prompting, task creation, and sub-agent orchestration for plans, emphasizing acceptance criteria for verification.
The methodology promotes one-task-per-context-window sessions, referencing summaries to avoid bloat. Definitions of done, global across projects, enforce testing, linting, and security checks. This counters “vibe coding’s” directional uncertainty, ensuring guardrails like unit tests prevent premature completion claims.
Implications extend to project readiness: documentation for agent onboarding mirrors human processes, with skills, code styles, and self-verification loops enhancing efficiency. Alex references a Factory.ai article on AI-ready maturity levels, underscoring documentation’s role.
Challenges persist in UI verification, requiring human QA, and complex integrations. Yet, the approach allows iterations without full restarts, leveraging cheap tokens for refinements.
Consequences and Future Directions
Backlog.md’s simplicity yields repeatability, boosting success from 50% (slot-machine-like prompting) to 95%. By structuring delegation, it mitigates AI’s non-determinism, fostering predictable workflows. Consequences include democratized AI use—no prior experience needed beyond basic Git—potentially broadening adoption.
For teams, Git synchronization enables collaboration, though self-hosting limits non-technical access. Future enhancements might include multi-repo support, integrations, and improved documentation, driven by its 4,600 GitHub stars and community feedback.
Broader implications question AI’s role: accepting “good enough” results accelerates development, but human input remains vital for steering and verification. As models improve (e.g., Opus 5.6’s million-token window), tools like Backlog.md evolve, but foundational structure endures.
In conclusion, Alex’s tool and methodology exemplify pragmatic AI integration, balancing innovation with reliability in an era where agents redefine development.