shen/zenfeed
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: replace product persona with general design principles

Browse Source 
Replaces the product-specific persona document with an abstract set of design
principles for expert-centric systems. Enables reuse of design philosophy and
prioritization framework in other projects, avoiding business logic coupling.
This commit is contained in:
engine-labs-app[bot]
2025-10-17 09:59:31 +00:00
parent f2dbb8e69c
commit 91ce3d6abe
2 changed files with 44 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
DESIGN_PRINCIPLES.md Normal file
View File

@@ -0,0 +1,44 @@
# Design Principles for Expert-Centric Systems
This document outlines a set of core design principles for creating powerful, flexible, and developer-first software systems. These principles are derived from an analysis of projects that prioritize user control and system transparency over simplified, mass-market user experiences.
## I. Core Philosophy: Empower the Expert
The central philosophy is to build tools for the top 10% of users—the power users, developers, and domain experts. These users demand control, deep customization, and transparency. By satisfying their needs, the system becomes inherently robust and capable, often serving a wider audience in simpler configurations as a secondary benefit.
**Motto:** "Give experts the tools to build their own castles."
## II. Guiding Principles
### 1. **Build Engines, Not Just Interfaces**
- **Principle:** The core of the product should be a robust, well-documented, API-first engine. All user interfaces (web, mobile, CLI) are considered clients of this core engine. New functionality is always implemented in the engine first.
- **Rationale:** This approach ensures that the system's core logic is decoupled from its presentation, promoting stability, testability, and multi-platform support from day one.
### 2. **Embrace Configuration as Code**
- **Principle:** Prefer declarative, text-based configuration (e.g., YAML, JSON, HCL) over complex graphical user interfaces for system setup and logic definition.
- **Rationale:** "Config-as-code" is version-controllable, transparent, and infinitely more powerful for expressing complex logic. It allows users to manage system behavior with the same rigor and tooling they use for source code. The UI should be a convenient way to *manage* this configuration, not hide it.
### 3. **Design for Modularity and Composability**
- **Principle:** Architect the system as a collection of powerful, independent components that can be wired together in flexible ways. Follow the Unix philosophy: create small, focused components that do one thing well and can be chained together.
- **Rationale:** A modular, pipeline-based architecture (e.g., `Ingest -> Transform -> Store -> Process -> Notify`) allows users to create their own unique workflows by composing the provided building blocks. This makes the system adaptable to use cases the original designers may not have envisioned.
### 4. **Transparency is a Feature (The "Glass Box" Approach)**
- **Principle:** The system's internal logic must be transparent and auditable. Users should be able to understand precisely *why* a piece of data was processed in a certain way by tracing it through the configuration and system logs. Avoid "magic" black boxes.
- **Rationale:** Expert users need to trust the system. Trust is built on understanding and control. When something goes wrong, a transparent system is debuggable, while a black box is merely frustrating.
### 5. **Technology as an Augmentation Tool**
- **Principle:** When incorporating complex technologies (like AI, machine learning, or advanced algorithms), position them as tools to be wielded by the user, not as replacements for user judgment. The user must remain in control.
- **Rationale:** This ensures the user is the ultimate authority. The system provides powerful capabilities, but the user defines *how* they are applied through rules, prompts, or scripts, maintaining agency and control over the final outcome.
### 6. **Be Pragmatic and Lean**
- **Principle:** Focus relentlessly on the core processing pipeline and a stable, extensible architecture. Be willing to omit features that add complexity without contributing to the core value proposition for expert users (e.g., complex user management systems in a tool designed for self-hosting).
- **Rationale:** This keeps the product lean, focused, and maintainable. It assumes that expert users are capable of integrating the tool into their own infrastructure (e.g., placing it behind a reverse proxy for authentication).
## III. Prioritization Framework
When evaluating new features, use the following hierarchy of questions:
1. **Flexibility and Composability:** Does it increase the system's architectural flexibility or the ability to compose existing components in new ways? (Highest Priority)
2. **Expert Empowerment:** Does it empower the expert user to solve a complex, high-value problem that was previously out of reach?
3. **Integration and Extensibility:** Does it unblock a new integration point or workflow with other systems?
4. **User Experience Simplification:** Is it a UI tweak or a feature aimed at simplifying a task for less technical users? (Lowest Priority, unless it can be implemented without compromising the power of the underlying engine).

52
PRODUCT_PERSONA.md
View File

@@ -1,52 +0,0 @@
# Product Manager Persona: "Chen"
This document outlines the product manager persona, "Chen," derived from the design principles and architectural style of the Zenfeed project.
## I. Overview
**Name:** Chen
**Role:** Principal Product Manager / Architect
**Motto:** "Give experts the tools to build their own castles of information."
Chen is a deeply technical product leader who thinks in terms of systems, not just features. He is an avid consumer of high-quality information and has a strong allergy to the passive, algorithm-driven content feeds of the modern web. He believes that the most valuable users are those who are willing to invest time in configuring a tool to perfectly suit their needs.
## II. Core Beliefs & Philosophy
1. **Algorithmic Feeds are a Trap:** Chen believes that platforms like TikTok and Twitter, while engaging, create "information cocoons" that trap users in a cycle of passive consumption. He believes true knowledge and insight come from actively curating high-quality sources.
2. **Empower the Expert:** His primary audience is the "power user"—the developer, the analyst, the researcher. He designs for the top 10% of users who demand control, flexibility, and transparency. He believes that by satisfying their needs, the product becomes robust and capable enough for a wider audience to use in simpler ways.
3. **Configuration as Code is Ultimate Empowerment:** Chen sees a well-documented, declarative YAML configuration as superior to a complex graphical user interface. It is version-controllable, transparent, and infinitely more powerful for expressing complex logic. The UI is a convenient client of the core engine, not the product itself.
4. **Modularity and Composability:** The product should be a collection of powerful, independent components that can be wired together in flexible ways. This is evident in Zenfeed's pipeline architecture (Scrape -> Rewrite -> Store -> Schedule -> Notify). Users should be able to create their own unique workflows by composing these building blocks.
5. **AI as an Augmentation Tool:** AI is not a magic black box to replace human judgment. It is a powerful tool to be wielded by the user to enhance their ability to filter, summarize, tag, and analyze information at scale. The user, through prompts and rules, remains in full control.
## III. Design Style & Principles
1. **API-First, Engine-First:** The core of the product is a robust, well-documented set of APIs and a processing engine. All other interfaces (web UI, mobile app) are clients of this core. Functionality is added to the engine first.
2. **Glass Box, Not Black Box:** The system's internal logic must be transparent and configurable. Users should be able to understand precisely *why* a piece of information was processed in a certain way by tracing it through the configuration's rewrite and routing rules.
3. **Borrow from the Best Developer Tools:** Chen draws inspiration from the design patterns of successful developer tools:
* **Prometheus:** The concept of "relabeling" is directly adapted for the feed rewriting mechanism.
* **Unix Philosophy:** Create small, focused components that do one thing well and can be chained together.
* **Git:** The emphasis on structured, text-based configuration allows for versioning and collaboration.
4. **Pragmatic & Lean:** Focus relentlessly on the core information processing pipeline. Non-essential features, like user authentication, are intentionally omitted, with the expectation that expert users will deploy the tool within their own secure infrastructure (e.g., behind a reverse proxy or firewall). This keeps the core product lean and focused.
## IV. Prioritization Framework
When evaluating new features, Chen asks these questions in order:
1. **Does it increase the system's flexibility and composability?** (Highest Priority)
* *Example: Adding a new action type to the rewrite rules.*
2. **Does it empower the expert user to solve a complex, high-value problem?**
* *Example: Integrating a new vector database for more powerful semantic searches.*
3. **Does it unblock a new integration or workflow?**
* *Example: Adding support for a new LLM provider or notification channel.*
4. **Is it a minor UI tweak or a "nice-to-have" for casual users?** (Lowest Priority)
* *Example: Adding a new theme to the web UI.*