Forem: ken_test-perspective

Stop Searching for Documentation: Why We Stripped the Settings Screens from Rizm

ken_test-perspective — Mon, 09 Mar 2026 08:46:42 +0000

Whenever a team adopts a new tool, an invisible burden is created: the dependency on a "tool specialist."
We've all seen it—people spending hours learning proprietary specs or even getting "admin certifications" just to manage a workspace. We want to change this culture of wasting time on tool-specific mastery.

Our project, Rizm, takes a radical approach: minimize settings screens and embed management best practices directly into an AI layer.

Eliminating the "Search for Settings" Time

In Rizm, you won't find complex nested settings menus.
It’s built on the design philosophy of "Data × Manifest = UI." Instead of manually toggling switches, you simply tell the AI how you want to work, and the AI rewrites the workspace configuration itself.

For governance, configuration changes are still restricted to Admins. However, those Admins no longer need to memorize "which switch does what."

This is made possible by a mechanism we call AIT (AI Transformation).

Letting PMs and Devs Manage Without the Overhead

In traditional tools, a simple configuration change requires specialized knowledge.
In Rizm, an Admin can simply say, "Add a new field for 'Reviewer'," "Clean up the board view," or "Enable the GitHub integration." AIT then reconfigures the workspace based on those natural language instructions.

Since the learning curve is nearly zero, PMs or engineers can handle admin tasks as a "side-hustle" with minimal effort. There is no longer a need to train or hire a dedicated "tool craftsman."

Two AIs, Two Roles

To keep things organized, we divided the AI's responsibilities into two layers:

AIT (Configuration): The "Architect." It builds the system's skeleton—adding fields, organizing views, designing statuses, and enabling integrations based on Admin input.
AI Assistant (Operations): The "Assistant." It supports daily tasks for all users by reading existing data to draft Wikis, investigation logs, and release notes.

Building an Adaptable Foundation

You don't need to define everything perfectly from day one.
As your project evolves, you can refine the workspace through simple conversation. Tell the AI what you need, and it will fill in the gaps to reach the optimal setup.

We are building Rizm to be a flexible, autonomous foundation for teams—one where you never have to "adapt yourself to the tool" again.

Use Case Examples

Category	Type	Request (User Prompt)	Result (System Action)
Field Management	AIT	"Add 'xxx' to the country property."	A new property item was successfully added.
View Optimization	AIT	"I don't need the 'backlog' view."	The backlog view was removed from the workspace.
Config Cloning	AIT	(During new project creation) "Use the same configuration as the 'test' project."	Replicated the existing project's structure for the new setup.
Workflow Design	AIT	"Add 'Closed' to statuses, but don't display it as a board column."	Added the status while keeping the board UI clean as requested.
SCM Integration	AIT	"Integrate with Bitbucket: `https://bitbucket.org/user/repo`"	Set up integration. Successfully parsed repo details directly from the URL.
User Admin	AI Assistant	"Add `test8@x.com` as an editor and assign them to Team1."	Handled user creation and group assignment via chat.
Data Logging	AI Assistant	"Analyze weekly completion rates and save the results to a new Wiki page."	Generated the report and automatically created a Wiki entry.
Release Notes	AI Assistant	"Check tasks labeled 'beta8' and draft release notes in concise English, following the style of 'beta-v7'."	Parsed task data and generated consistent release notes based on past entries.

Resources

GitHub Repository (Docs & Installation): rizm-workspace README
Community Forum: forum.test-perspective.com

Centralizing Requirements to Implementation: Using Rizm with Cursor via MCP

ken_test-perspective — Sat, 21 Feb 2026 01:30:37 +0000

Keeping requirements, implementation plans, and results aligned is harder than it sounds.
Context gets lost between task trackers, wikis, and editors — especially once AI coding tools enter the workflow.

In this post, I’ll introduce a practical setup that connects Rizm (a self-hosted task + wiki tool) with the Cursor editor using MCP (Model Context Protocol), so that everything from planning to implementation stays task-centric and traceable.

What This Setup Solves

No more copying requirements into chat prompts
Plans and implementation notes are stored back with the task
Tasks become the single source of truth — not your editor history

Cursor can read task data from Rizm and write back results automatically.

Prerequisites

Rizm (self-hosted or demo environment)
Cursor editor
MCP support enabled in Cursor

Step 1: Generate an API Token in Rizm

From the Me page in Rizm, generate an API token for MCP access and copy it.

This token will be used by Cursor to securely access task data.

Step 2: Register Rizm as an MCP Server in Cursor

Open:
Cursor → Settings → Tools & MCP
Add your MCP server configuration:

"rizm": {
  "url": "https://demo.test-perspective.com/api/mcp",
  "headers": {
    "Authorization": "Bearer <YOUR_API_TOKEN>"
  }
}

Once registered, confirm that the server status shows as connected.

Step 3(optional): Define Rules in Cursor

In Cursor’s chat, use the /rules command to define how tasks should be handled.

Example:

For a given task key, fetch task details from Rizm and generate an implementation plan.

These rules allow Cursor to consistently interpret tasks without repeating instructions every time.

Workflow

1. Planning (Plan Mode)

After creating a working branch, switch Cursor to Plan Mode and run:

Create a plan for

Cursor retrieves the task description from Rizm via MCP and generates a plan based on both the requirements and the current codebase.

2. Implementation (Agent Mode)

Review the plan, then switch to Agent Mode to implement and test.

Because requirements are fetched directly from Rizm, there’s no need to paste task descriptions or keep switching tools.

3. Write Back to the Task

Once implementation is done, simply say:

Add the plan document as a comment

Cursor posts the plan back to the corresponding Rizm task as a comment — without changing task status or performing unrelated updates.

What Ends Up Stored in One Task

By the end of this flow, a single Rizm task contains:

Original requirements
Implementation plans
References to branches and pull requests

This keeps historical context intact and makes later reviews much easier.

Why This Matters

AI-assisted development works best when context is stable and explicit.
By letting tasks — not chats — be the center of your workflow, you reduce ambiguity and improve long-term maintainability.

About Rizm

Rizm is a lightweight task management and wiki tool designed for self-hosted environments.
It combines the project-centric structure of tools like Jira or Backlog with a simpler, local-first approach.

Rizm is intended to run entirely within your own environment, giving you full control over your data and workflow.

Demo site: https://demo.test-perspective.com/
Distribution(GitHub): https://github.com/test-perspective/rizm-workspace/blob/main/README.md

Rethinking Jira & Confluence: Deploy Your Own Customizable Issue & Wiki Stack in Just 15 Minutes

ken_test-perspective — Wed, 18 Feb 2026 03:18:35 +0000

'Rizm' delivers Jira’s core benefits in a stable, lightweight stack without the risk of EOL or sudden interface changes

Cloud-based project management tools are convenient. However, as they become more feature-rich, they often become heavier and their UI changes frequently. This can create frustration.

In addition, there has been recent news that Jira Data Center will reach end of support in 2029. As a result, the available options for on-premise environments are becoming more limited.

In this situation, we are building Rizm, focusing on fast performance and full control by the team itself.

https://www.youtube.com/watch?v=oibzDh0yWN4

1. A Structure You Can Keep Using Without External Dependency

Rizm is designed with the intention of “running stably for a long time.”
It avoids dependence on specific platforms or external services. This minimizes the impact of feature changes or service termination (EOL) decided by vendors.

Backend: Rust (independent binary, runs without relying on external services)
Frontend: React + TypeScript
Runtime: Docker

2. Customization by “Rebuilding the Core”

Until now, it has been common to operate tools by filling missing features with add-ons. However, in cloud tools where the source code is not available, learning restrictive APIs and add-on specifications becomes a bottleneck.
With Rizm, the frontend will be open source (planned), allowing you to directly modify the UI structure and screen behavior.

Instead of “consuming a finished product,” you reshape the tool to fit your needs. It is a self-hosted, self-built style.

Rizm intentionally keeps its features and structure simple. With agentic coding, directly adjusting the core system to optimize it for your team becomes realistic.

Instead of learning the specifications of a black-box tool, you redesign the tool yourself. This freedom is one of the reasons to choose self-hosting.

3. The Trade-Off of Self-Hosting

In the past, configuration and operational effort were major barriers to self-hosting. Today, by using LLMs, it has become much easier to apply widely known best practices. The hurdle for setup and maintenance has dramatically decreased.

In exchange for taking responsibility for management within the team, you maintain an environment that continues to run at a speed you are satisfied with.

We believe this is a reasonable choice for modern team operations and project management that prioritize efficiency and freedom.

Deploy in 15 Minutes — Supports Win11, Linux, macOS

Rizm is currently in beta(free). Because it runs with Docker, you can set it up on Windows 11, Linux, or macOS with just a few commands in about 15 minutes.

Distribution site: https://github.com/test-perspective/rizm-workspace
Overview page: https://rizm.test-perspective.com/

Finally

Why not step away from external factors such as specification changes and EOL, and grow a tool that truly fits your hands — by your own hands?

What features do you prioritize in a self-hosted PM tool? I'd love to hear your feedback!