How are you using SloplessCode?

[Utundry]

How are you using SloplessCode?

I'm seeing a growing number of GitHub clones and Docker pulls, but very little public feedback.

If you're using SloplessCode, I'd love to learn more about your workflow and use cases.

A few questions:

• Which agent are you using? (Claude Code, Roo Code, Codex, OpenHands, Cursor, etc.)
• What problem were you trying to solve?
• How did you discover SloplessCode?
• What worked well?
• What was confusing or difficult?
• What would you improve first?

You don't need to answer everything. Even a short comment is valuable.

I'm especially interested in real-world experiences with:

• long-running coding sessions;
• context continuity;
• agent memory;
• task lifecycle management;
• preventing project drift and AI-generated slop.

Whether you're experimenting, actively using it, or abandoned it after a test run, I'd love to hear your experience.

Thanks for trying SloplessCode.

[Utundry]

My experience: why I no longer need a giant project prompt

One of the most surprising effects of using SloplessCode is that I no longer start projects by writing a massive project prompt.

Previously, I tried to describe everything up front:

• project goals;
• architecture;
• constraints;
• implementation details;
• coding conventions;
• future plans.

The prompt kept growing, and every new session required rebuilding context again.

Today my workflow looks very different.

I usually start with a discussion.

I throw ideas onto the table, often in no particular order. Sometimes they are features, sometimes architectural concerns, sometimes observations from previous work. The process feels similar to dumping all puzzle pieces from a box onto a table before assembly.

At that stage there is no complete plan.

The agent helps organize the pieces.

Once enough ideas exist, I ask questions such as:

• Which problem is most important?
• What should be done next?
• Which task provides the highest leverage?

The agent proposes priorities, explains tradeoffs, and often turns vague ideas into concrete task definitions.

I review the proposal, discuss details, and either approve or adjust it.

Only then does implementation begin.

After approval, the work follows a structured lifecycle:

idea → task framing → discussion → approval → implementation → checkpoint → completion

The result is that project knowledge emerges gradually instead of being forced into a single giant prompt at the beginning.

In practice, this feels much closer to how human teams work.

The most valuable change is not memory itself. It is the ability to continuously organize, prioritize, and evolve project knowledge without repeatedly reconstructing the entire project context from scratch.

[Utundry]

Another important change is that ideas no longer have to be implemented immediately.

In a traditional AI workflow, useful ideas are fragile. If they are not implemented during the current session, they are often forgotten, partially remembered, or lose their original context.

With SloplessCode, ideas can be captured the moment they appear.

I can record an observation, an improvement proposal, an architectural concern, or a future feature today, even if I have no intention of working on it right now.

The implementation might happen a week later, a month later, or after several other priorities have been completed.

The important part is that the idea does not disappear.

When the time comes, the agent can recover not only the idea itself, but also:

• why it was proposed;
• which problem it was trying to solve;
• related discussions;
• linked tasks and improvements;
• the surrounding project context.

As a result, planning and implementation become decoupled.

Ideas can emerge whenever they appear, while execution can happen when it makes sense.

This makes long-running projects feel much more natural. Project knowledge accumulates over time instead of being repeatedly reconstructed from memory.