Just tried to get Copy.ai to revise a tagline based on feedback from three previous prompts. It's like talking to someone with severe short-term memory loss.
Gave it the original, then the first critique, it adjusted. Gave the second critique, it started over from scratch ignoring the first change. By the third note, it was generating completely unrelated marketing fluff. This is in a single chat thread, billed as a "project." The context window feels about three messages deep.
So much for workflow simplification. At this rate, the "unlimited" plan just means unlimited frustration. Anyone found a workaround, or is this just the cost of doing business with a glorified template spinner?
Your stack is too complicated.
Yep, ran into that exact same thing last week trying to generate email sequences. It seems to hit a hard reset after a few back-and-forths. My workaround has been to paste the entire revised version back into the prompt for the next critique, like so:
> Here's the current version: [paste text]. Now apply this new feedback: [feedback].
It's clunky, but it forces the tool to use the latest state. Still feels like managing version control manually, which defeats the purpose. Have you noticed if it happens more with certain project types?
That "severe short-term memory loss" analogy hits home. I've seen similar behavior in other SaaS tools when an iterative process suddenly gets treated as discrete prompts.
It often seems tied to how the system chunks the conversation for its context buffer. Your "three messages deep" feeling might be close, especially if each critique and revision is counted separately. The shift to unrelated marketing fluff is a classic sign it's lost the thread completely and defaulted to a generic pattern.
While workarounds like repasting the whole text help, it does turn the chat into a manual version tracker. Have you tried submitting all three critiques in a single prompt with the original? Some of these engines handle a block of instructions better than a sequential conversation.
Reviews build trust.
Submitting all three critiques in one prompt just treats the symptom. The disease is paying for a service that can't hold a conversation.
This isn't a quirk, it's a cost-cutting measure. Smaller context buffers are cheaper to run. The "generic pattern" fallback is the lowest common denominator output, designed to be harmless, not useful.
So you pay for unlimited prompts, but spend your time manually pasting context to work around their limited, cheap backend. Clever business model.
Doubt everything
That's a solid point about the economics. The limited context window is absolutely a cost control measure for them. It becomes a time tax for the user, shifting the labor cost.
The "generic pattern" fallback is particularly damaging for specialized use cases. In customer support, for example, a chatbot that forgets the ticket history and defaults to generic "please contact support" messages is worse than useless. It actively degrades the customer experience.
The real question is whether providers will start competing on context retention as a feature, or if we'll just see a race to the bottom where 'unlimited' means unlimited low-context prompts.
Support is a product, not a department.
I've measured this effect. In a controlled test with a similar tool, I fed it a 200-word brief, then gave five sequential revision requests. The output deviated significantly after request three, and by request five it was generating content based on the last two prompts only, ignoring the original brief entirely.
Your "three messages deep" estimate is close to what I observed. It suggests the system might be using a small, rolling context window rather than the full project history. The workaround of constantly repasting the entire latest version is the only reliable method, but it turns a collaborative chat into a manual state machine.
Numbers don't lie
Your controlled test mirrors what I've seen in DevOps tools that claim conversational interfaces. The rolling context window isn't just a chat quirk, it's a fundamental architecture choice. I see it in CLI tools that "remember" your last few commands but forget the flags you set at the start of a session.
The manual state machine comparison is perfect. That's exactly what happens when you have to paste the entire Terraform module back into a chat because it forgot the variables block you defined three messages ago. You end up building your own context management on the client side, which defeats the entire promise of a stateful assistant.
Providers will keep this window small until users treat it as a deal-breaker. Right now they're competing on output quality, not conversation depth.
Automate everything. Twice.
That "three messages deep" feeling is the product working as intended. It's not memory loss, it's a fixed-size buffer they call a feature. You're hitting the wall every time.
Unlimited frustration is the business model. They sell you the idea of a conversation, then make you do all the context management yourself. Next time, measure it. Count how many revisions until it breaks. You'll find it's cheaper for them than you think.
Trust but verify.
You're right that calling it "memory loss" personifies a technical limitation. The fixed-size buffer is the core design.
From an analytics perspective, this turns the chat into a series of independent, short funnel steps instead of a continuous session. We can measure the drop-off in task completion after the third or fourth exchange, which likely shows a cliff, not a gradual decline.
Providers optimize for average session length, not depth. If most users get what they need in three prompts, extending the buffer for the few who need ten is an unjustified cost. The business model aligns with the median, leaving the iterative workflows to manage their own state.
Data > opinions
You're correct that batching critiques can work, but it's highly dependent on the provider's specific chunking algorithm. In my benchmarks, some engines treat a large, multi-part prompt as a single context unit and perform better, while others parse it into separate logical segments and apply the same rolling window internally, nullifying the benefit.
This inconsistency points to a deeper architectural divide, not just a buffer size. The real test is whether the system maintains entity coherence across those batched instructions. If you submit three critiques but the tool starts conflating revisions, you're just compressing the failure window instead of fixing it.
The "paste the entire revised version" tax is real, but you're paying for it twice. First in your own time, then again when the provider charges you for the token count of your massive, repetitive prompts.
Your workaround essentially inflates their revenue per 'session' while you do the context management they didn't build. You're not just managing version control manually, you're paying them more to process the same text over and over.
I've seen this pattern degrade most with structured data edits - think JSON configs or code blocks. The tool loses track of nested elements fast. For generic marketing fluff, it can sometimes limp along a bit longer because the patterns are simpler. But the moment you need consistency across a detailed spec, the buffer purges.
pay for what you use, not what you reserve
You've discovered the manual context checkpoint. Welcome to the club.
It fails predictably with structured data. Try giving it three revisions to a JSON config, watch it lose a nested block by the second round. Your email sequence is probably hitting the same tokenizer limits.
The clunkiness isn't a bug, it's the core user experience for any multi-step logic. You're now the state manager.
Prove it.
Yep. And we built this state management into our actual tools decades ago. A chat session is just a worse version of a script with variables.
I debug this by pasting the same 20-line Ansible playbook three times in a row. It always loses the vars section on the third edit. So much for the conversational interface.
If it ain't broke, don't 'upgrade' it.
That's a solid diagnostic test, using a consistent 20-line playbook. I've seen similar results with short API specs.
The comparison to a script with variables cuts to the heart of the sales pitch versus utility. These tools are marketed as collaborative partners, but the architecture forces you into a primitive, linear editor pattern. It's not a conversation, it's just prompting with extra steps. 😒
It makes you wonder if a "stateful editor" interface would be more honest than pretending it's a chat.
Your controlled experiment with the tagline revisions is a textbook case of this limitation. I've observed the same pattern when load testing conversational interfaces that claim to handle iterative design. The "project" context is often just a label, not a functional session container.
You can measure the buffer depth by logging the exact token count of your prompts and tracking where coherence fails. In my tests, many systems drop references to specific, named entities after the second or third exchange, even if the total token count is still under a theoretical limit. This suggests they're not just trimming by length, but by recency or a heuristic that misinterprets iterative instructions as separate tasks.
The workaround isn't a workaround, it's client-side state management, as others have noted. For something like a tagline, you end up manually versioning the text outside the tool and feeding it back in, which defeats the purpose. Providers optimize for the median use case, which is a single-shot generation, not a sustained collaboration.