Deniz

Building AI Products & Developer Tools

[Deniz @denizm_dev]

fair, the "when" is the real problem. that's actually why we built Frame (https://t.co/ZSfZ60wOic). it keeps a memory file per task (what/why/result) as the agent works, so compaction never hits an empty slate. no extra summary calls, it's just part of the flow. open source & free if you want to try it

[Deniz @denizm_dev]

fastest way to get spaghetti from an AI agent: let it start coding before you've agreed on a plan.

with Frame you write a short spec first. it becomes the plan your agent follows, and it stays in the repo for the next session too.

free and open source: https://t.co/9CIi4D3CzC

[Deniz @denizm_dev]

@aleximarkett same conclusion here. once the plan and past decisions live as files in the repo instead of in a chat, a new session just reads them and keeps going. that's what i'm building Frame around

[Berkay Yılmaz @FarotherDev]

In the last 5 months of building a new product with AI, we made 670 product decisions.

I wrote personal opinions about why knowing them, and planning before you build, matters even more today. https://t.co/sVhls91Vqd

[Deniz @denizm_dev]

yapay zekayla kod yazarken en sinir bozucu an: geçen hafta beraber aldığınız kararı bugün baştan tartışmaya açması.

Frame kararları, planı ve kalan işleri repoda dosya olarak tutuyor. yeni oturumda ajan nerede kaldığınızı biliyor.

ücretsiz, açık kaynak:
https://t.co/JTNmyQ08Li

[Deniz @denizm_dev]

@akarik3873 makes sense, i probably wait too long to clear. what made clearing painless for me was keeping decisions and open tasks in files in the repo, so a fresh session isn't starting from zero. that's actually why i'm building Frame

[Deniz @denizm_dev]

your AI coding agent wakes up every morning with no idea what your project is.

so you explain it again. and again.

Frame keeps the plan, past decisions and open tasks in your repo, so every new session picks up where you left off. free and open source.

https://t.co/9CIi4D3CzC

[Deniz @denizm_dev]

@apoorvdarshan the AGENTS.md rule is the underrated part, without it every new session picks its own browser setup and you debug the same login again

[Deniz @denizm_dev]

@stretchcloud a generic taste skill gets you off purple gradients but not to your look. what stuck for me was writing the project's own design calls in a file in the repo next to it

[Deniz @denizm_dev]

@gergomoricz the dump at the end is the fix, doing it continuously is the cure. i have the agent update a migration notes file in the repo after every step, so no thread ever becomes the one you can't close

[Deniz @denizm_dev]

Everyone runs agents now. We mapped 6 AI coding tools honestly, dashes included.

Frame's focus: your team's decisions live in the repo, so the next agent starts from what you already decided.

Open source · BYO agent · https://t.co/9CIi4D34K4

Sources: public docs, Oct 8 2026

[Deniz @denizm_dev]

AI agents write the code now. Context still disappears.
As projects grow, things fall apart fast:
→ Context loss: every new session starts from scratch, and you re-explain the same architecture again and again.
→ No project memory: the agent doesn't know your past decisions, your conventions or what's still pending.
→ No standard: every developer structures AI projects differently, so collaboration and onboarding suffer.
→ Sessions bleed together: juggle a few projects and their contexts start mixing.
→ Terminal chaos: windows everywhere, scattered sessions, no organization.
→ Tool fragmentation: Claude and Codex work differently. Your context shouldn't care.
Manageable on small projects. Blockers on large ones.
Frame solves all of this. Free and open source, built on Claude Code.
https://t.co/ZSfZ60xm7K

[Berkay Yılmaz @FarotherDev]

Three months into a project, I asked my agent for a change and it stopped me. The change would break a decision we made in a spec 50 days earlier, and it told me which spec, what we decided and why. It did not read the codebase to find this out. It barely spent any tokens.

Remembering a project is not the same as re-reading it. An agent can rebuild a lot by scanning code, but code only stores the results of decisions, never the decisions. Scanning is expensive, and it still misses the one thing you needed: why the code is the way it is.

So recall works on keywords, not on code. Every spec gets keywords when it's written, and when it's finished it gets an outcome file: what was built, what was decided, what was rejected. When new work starts, the agent gives the new work its keywords, matches them against the keywords already on file, and opens only the decisions and outcome files that match. In my repo there are 68 specs. A lookup returns about 200 bytes: the related spec, one line of summary, and where to read more if it matters.

This works the same with Claude Code or Codex, no matter which model is behind it. We built it into Frame, an open-source environment for agentic development. How does your agent find out a change breaks a decision you made months ago?

[Erdal Bektas @eeebektas]

Vibe coding yaparken projeye her seferinde yeniden mi başlıyorsunuz? Ne dediğinizi tekrar tekrar anlatmak zorunda mı kalıyorsunuz?

Sizin derdinizin dermanı, ADE. Yani Agentic Development Environment.

ADE nedir? Başta yaptığınız planlamadan itibaren, her adımınızı tek tek hafızaya yazan, paylaşılabilir bir proje hafızasıdır.

Peki biz nereden bulacağız bu ADE çözümünü dediğinizi duyar gibiyim! Onu da yapan bir Türk geliştirici var; Kaan. Alıp kullanacaksınız.

[Deniz @denizm_dev]

If the value of a tool only shows up after three months of use, most people will never see it. That was the uncomfortable thing I had to admit about the decision corpus we have been building for agentic development.

A long-running memory is not the same thing as a first impression. The corpus pays off when an agent six months from now asks why a file looks the way it does and gets the original spec, the plan, and what actually happened. Nobody waits six months to find out whether that works.

So we made a small sample repo where the loop closes on the first run. You clone it, open it, run one spec through implementation, and the agent writes an outcome.md: what was planned, what changed, what drifted from the plan and why. Then you open a file that spec touched in a new Claude Code or Codex session, and the hook injects that history before the agent reads a line of code. No matter which model is on the other end, it starts from the decision, not from a guess.

The fair objection is setup. It is not zero, and it currently expects Claude Code. That is written in the README rather than discovered halfway through.

We built this into Frame, an open-source Agentic Development Environment. If you try the sample, I want to know one thing: did the outcome.md tell you something the diff didn't?

https://t.co/cpAbhKEFDv