Coda's Two-way writeups and the functionality to enable them

I’ve just been reading some interesting Coda articles on some of their work management processes and tools/flows/systems. They use Coda, naturally. One thing they’re big on is interactivity, which Coda documents make fairly easy to do through various embeddable widgets, tables, etc., most of which you can interact with. It strikes me that similar kinds of things will be useful for the planned future of Fibery as a feedback portal. But I’m interested in looking at the “two-way writeup” as a particular case, for a moment.

The points about the limitations of Google Docs-style comments are important, I think. I have often had the experience of increasing friction and, ultimately, frustration when a simple comment in a GDoc turns into a conversation and then quickly becomes unwieldy in the tiny comment box, with a lack of quote ability, and many other limitations. And while Fibery (and Notion, but especially ClickUp) have different, perhaps slightly better comment tools, they still have the problem of unbounded feedback that becomes silo’d and thus is hard to surface, organize, prioritize, and make further sense of.

There is power and value in that free-form commenting capability too, however. So I’m honestly unsure about Coda’s proposed fixes, using “reacts”, specific question prompts, and specific feedback areas. I can see the benefit of them, and overall it does seem like a more structured approach that makes next-actions more clear. I like that about it. But it also feels possibly too rigid. I’d be curious if anyone here has thoughts on this or, especially, direct experience using this kind of approach!

What I’d really like to have is some hybrid approach. Let’s say you keep the current comment model of Fibery, etc., where you can make in-line comments and they show up where they were added, they can be replied to, etc. Perhaps adding threading would be nice, and maybe assignable comments, and other small improvements. These things take care of certain problems. But I think there still remain some challenges around making sense of discussions after they run their course, deriving not just quick action items (for which comment assign is appropriate), but higher-level decisions, meaning, etc.

So, just brainstorming here, if we could link to individual comments in an easy way, perhaps this could be a way to sort of “promote” a comment by referencing/collecting it somewhere else, to represent e.g. a decision that was made, or a particularly salient point that suggests a question for all to discuss in a more formalized way. I’d want this to not just be collecting a comment into a specific e.g. extension like “References”, but more like a free-form “mention”/link, as we can with any Entity (and as the above linked discussion outlines). Ideally it could also embed some context from the linked comment though (optionally). Maybe even bi-directional linking could be a part of this (e.g. with a small indicator on each comment showing how many times it is linked to, click or hover on it and you get a list with links to references), although I’m not totally sold on the actual utility of this.

To give a specific example, let’s say I’ve written a document regarding a new feature and put it out for initial comment. A discussion occurs around the actual UI for this new feature, and how it will meet accessibility requirements for e.g. people with disabilities. This is an important question, and while a few people chime-in on the original discussion, it’s basically buried in a comment thread.

After an initial, perhaps previously specified “open discussion” period (something perhaps missing in the Two-way writeup example from Coda), the document author and/or team (or perhaps even anyone who is a stakeholder, optionally) then do a “summarizing” phase, before a more formal comments and proposals period. Any stakeholders can go through the document as well as the comments and link/promote text/quotes and comments into a Coda-Two-way-like interactive table at the bottom, framing questions, key takeaways, etc. for further vote and comment. Essentially surfacing the most important discussions, questions, conclusions, etc. without having to rewrite anything, and maintaining their original context for reference as-needed. This to me seems like an improvement on what Coda uses, and arguably a decent hybrid of the free-form comment benefits with the structured Two-way writeup benefits.

Perhaps a different way of doing the above, that would work more universally (and is something I’d be excited to see), would be some kind of semi-ubuquitous quote-link function, much as we have here in Discourse (and which I have referenced before as a great example of this type of functionality). Essentially every time you highlighted text anywhere in Fibery, you could have the option to “copy quote link”, which would put in the paste buffer the actual quoted text, and a link to that Entity or other source that, when pasted anywhere in Fibery, would retain that link back to its original context, and represent it as a quote, or other clear reference back to its source. This is one way to more freely mix content without the potential rigidity of “blocks”.

To visualize how it would work, experiment with Discourse itself here, while composing a message. Except that you wouldn’t have to quote into a compose window as you do here, it could be copied and pasted from anywhere in Fibery, in any new tab/window. I think Discourse provides a good model of how to represent quotes, expandable context, links back to source, etc. Although ideally I would want a system that allowed for choices in how quoted text was represented, e.g. if I want to actually make that quote a part of a new document, while maintaining the back link, I don’t want it to look like a quote, but it should still differentiate itself, just more subtly, showing it came from somewhere, but is also mostly formatted like its new context (see “block references” in apps like Roam Research).

So basically I’m interested in a few areas of consideration here:

  1. Does the actual idea of Two-way write-ups seem advantageous to you vs. current comment models (e.g. GDocs, Fibery, etc.)?
  2. Does the specific implementation Coda uses seem like the best approach?
  3. Will the kinds of tools that Coda uses in their implementation (interactive widgets, etc.) be a part of Fibery’s future capabilities? If not yet planned, do you think they should be?
    a. What other use cases might you see for such things? Perhaps public feedback management? E.g. voting on features, etc.
  4. Is there a better way to do all this? Perhaps something that is a hybrid, as I roughly describe above.

Anyone have any thoughts on experiences with all this?


Perhaps the ability to “promote” a comment thread (or part of) into a new first-class entity would be useful. The new entity could then be automatically transcluded into the original context, and hopefully some of its fields would also be automatically set.


Cool thread! We are thinking around this problem for some time already, let me provide my thoughts.

  1. Now we have three tools to create docs (essentially). Text Editor, Comments, Chats. You missed chats in your problem definition, but we see that many people just throw a link into Slack and discuss the content in Slack. It’s a pure disaster, since there is no context and later you have to manually copy/paste relevant things into a doc. Why people are doing it? Well, Slack is tailored for discussions in general, while almost all text editors don’t. Comments in Fibery/Coda/GDocs are RIDICULOUSLY bad.

  2. We are thinking about merging Text Editor, Comments and Chat functionality into a single tool that will enable content co-creation, closing all feedback loops in a single tool. That is somewhat similar to two-ways writeups, but much more deeper in my opinion. Coda states the right problem, but does not really provides a solution, these examples give marginal improvements IMHO (like 10% better). We need a more radical solution that will be at least 2x better.

  3. It seems Blocks will enable this paradigm shift in Fibery. We don’t have any prototype yet, but overall main ideas are:
    – compose documents using semantic text blocks. For example, important part can be a separate block.
    – every block will have a thread of messages(comments).
    – every message is a block itself, so you can move it to the main document as a new section, transclude onto a document (this is close to your Discourse quote example), add emojies, create new entities from a comment (like new task linked to discussed feature), etc.
    – thus discussions will be mixed with the content itself and will be a first class citizens in a system (they will take the same space as the main text in a doc)

This is a very rough sketch below, that shows a part of a large document about Chat in Fibery. Problems is the first section and it is a separate block, so people can react on it (set emojis), and discuss just this topic. Interesting comment can be inserted into the main document. For example, you may create a new section about Technical Problems from an insightful comment.

Again, the main idea is that Comment/Message is just a block and you can do crazy transformational things with it.

I have an intuitive feeling that something similar can transform how teams collaborate around text.


You’re right, I left out chats, probably because I kind of hate Slack, and chat in general, as a work tool. It has some benefits, yes, but I feel like it creates almost as many problems as it solves. Sounds like maybe you agree somewhat.

It’s also interesting how strongly you feel that comments are bad in all tools. :grinning_face_with_smiling_eyes: I don’t even think they’re that bad when done well, but you’re right that they are not nearly good enough.

:open_mouth: Interesting, chat seems like a whole, big problem of its own. Though I guess it depends on how you approach it, how important real-time responsiveness is, etc. I have been seeing the ways these lines could blur in how Discourse is actually implementing built-in chat soon (early testing maybe in December), for example. I’m curious how much work it would be to do this in Fibery, and a bit surprised it seems to be a likely direction. Surprised but not displeased. :wink:

Yes, I think you’re absolutely right there. It’s an incremental improvement, not a dramatic one. And it leaves some critical issues still unresolved.

Mmmm, yes. Many apps are going this way, and it’s great (albeit at times confusing). Roam (everything a “block”), RemNote (everything a “rem”), Mem (everything a “mem”, I believe), Anytype (everything an “object”). Will Fibery use its own fancy, proprietary term to refer to these? Are they all “Fibers” and a full Document/Entity is now a “Strand” or a “Bundle”? :grinning_face_with_smiling_eyes: (just kidding, “block” or “object” are great)

Indeed, this sounds quite promising. But I also think I really can’t quite visualize how it will work and feel without trying it, or at least a prototype. Hard problem. You must do some (major?) work in order to see if the work is worth doing. :thinking: A common dev challenge, I know…

I tend to agree. Glad you have some good ideas around this, and hopefully not so far from implementation! The world needs this. Existing concepts - like Coda’s - are interesting and useful, but not complete solutions. Honestly if you guys weren’t building this block-based future iteration of Fibery (or at least talking seriously about it), I might be tempted to experiment more with Coda, but nobody seems to have a better publicly expressed vision around this than you guys, at least for teams and work…

1 Like


Notion be like:


Fibery be like:



1 Like