DEV Community: SupermanSpace

Rebuilding DEV’s Community Buddy to Actually Take Actions

SupermanSpace — Thu, 30 Jul 2026 15:57:27 +0000

DEV recently added DEV Community Buddy BETA to the post editor, giving writers an AI assistant for Markdown, formatting, embeds, and community guidelines.

The idea is useful. The execution still feels like a chatbot placed beside the editor.

When I tested it, the assistant could explain how to complete a task, but it could not perform that task inside the writing workflow. It did not clearly show what part of the draft it could access, how long the conversation context would persist, or whether the session belonged to the current post. Opening the assistant also reduced the editor space and created a separate interface that competed with the writing experience.

That made me curious about a larger question:

What would DEV Community Buddy look like if it could understand the active draft and safely take actions inside the editor?

Since DEV runs on Forem, an open-source community platform, I downloaded the project and set it up locally. I then started integrating the open-source YourGPT Copilot SDK to turn the assistant from a passive question-and-answer panel into an editor-aware copilot.

The goal is not to replace DEV’s beta or dismiss an early experiment. It is to explore the next step: an assistant that can read the current writing context, rewrite selected text, insert Markdown, suggest tags, prepare cover-image prompts, and apply approved changes without forcing the writer to copy and paste everything manually.

This post is that exploration: how I built it, how others can reproduce it, and how the same pattern can extend beyond the editor (stats, reading lists, account settings). Credit to @ben , @jess and everyone who maintains DEV and Forem—the open platform and editor this depends on. If the product team reads this, treat it as a field report: keep what helps, ignore what does not. Actionable tools in the draft (and later across the product) are the direction I found useful to implement and document.

Demo

The problem I was trying to solve

DEV Community Buddy can already help with basic writing questions. It can explain Markdown, suggest wording, answer questions about DEV, and generate text inside the side panel.

The limitation is what happens after the answer appears.

I was not trying to build a better chatbot for brainstorming. I wanted the copilot to complete the small, repetitive actions that slow writers down while finishing a post:

“Fill four relevant tags” → the tag fields are populated
“Tighten this paragraph” → the selected paragraph is replaced
“Add a TL;DR” → a formatted section appears at the top
“Write an introduction for this title” → the title remains unchanged and the introduction is inserted into the body
“Outline the remaining sections” → Markdown is added at the current cursor position
“Convert this Mermaid diagram” → a PNG is generated and inserted into the post
“Create a cover image” → the image is generated and connected to the article
“Proofread this selection” → corrections are applied without replacing the rest of the draft
“Add citations” → relevant sources are found and inserted in the correct format

A side panel that only returns text still leaves the writer with the same workflow:

select → ask → copy → paste → repair formatting → return to writing

That is useful during ideation. It becomes friction when the draft is nearly complete.

The important context already exists inside the product:

Article title
Tags
Body content
Selected text
Cursor position
Focused field
Current draft
Authentication and CSRF state

The copilot should use that state instead of asking the author to repeatedly describe or paste it.

The design principle was simple:

The model decides what should change. Product-side handlers decide how that change is safely applied.

The model does not directly manipulate the page. It selects from a controlled set of tools such as updateTags, replaceSelection, insertMarkdown, or generateImage. Forem remains responsible for validating and applying each change.

This creates a clear separation of responsibility:

The model interprets the author’s intent
Client tools expose permitted product actions
Forem handlers update the real interface
Sensitive credentials remain on the server
The author reviews the result inside the existing workflow
Generated content does not need to be copied back manually

This is the difference between adding AI beside a product and making the product operable through AI.

The implementation follows the client-tool pattern provided by the YourGPT Copilot SDK.

How I Turned DEV Community Buddy Into an Action-Capable Copilot

In my version, DEV Community Buddy is no longer a detached assistant that only returns suggestions inside a side panel.

Using the YourGPT Copilot SDK, I connected Buddy to a controlled set of tools that can read the current article state and perform actions directly inside the DEV writing experience.

Each tool is bound to a specific part of the post, including the title, tags, body, selected text, and media.

Actions connected to the article editor

Request	What Buddy does
Set or improve the title	Updates the title field as plain text without adding a Markdown `#`
Fill the tags	Selects up to four relevant tags through Forem’s existing chip interface
Write an introduction, outline, or section	Inserts Markdown at the cursor, start, or end of the article
Rewrite the full article	Replaces the body only when the request clearly applies to the complete draft
Rewrite selected text	Replaces only the highlighted text
Make selected text shorter	Condenses the selection without changing the surrounding content
Proofread selected text	Fixes grammar, spelling, and clarity in place
Add a TL;DR	Generates and inserts a formatted `## TL;DR` section at the top
Generate a cover image	Creates an article image and connects it to the publishing workflow
Convert Mermaid to PNG	Renders a Mermaid diagram as an image and inserts it into the article
Add citations	Finds relevant sources and inserts citations where they are needed
Continue writing	Uses the existing draft and cursor position to extend the article naturally

The important difference is that every request maps to a real product action.

Buddy does not simply return a paragraph and leave the author to decide where it belongs. It understands whether the result should update the title, populate the tag fields, replace selected text, or insert Markdown at a particular position.

Editor behavior that mattered in practice

Behavior	Why it matters
Replace only the selected text	Prevents a small edit from accidentally changing the full draft
Insert at the cursor, start, or end	Adds content where the author expects it
Add the TL;DR at the top	Creates the correct article structure automatically
Remove a leading H1 from generated body content	DEV already stores the title in a separate field
Preserve the selected range	Keeps the correct text available after focus moves to the copilot
Use the real tag chip interface	Preserves Forem’s existing validation and interaction patterns
Apply every action once	Prevents duplicate text, repeated tags, or multiple insertions
Keep API keys off the client	Ensures sensitive credentials remain on the server
Require controlled tools	Limits the model to actions explicitly exposed by the product

These details may sound small, but they determine whether the copilot feels reliable.

Generating good text is only one part of the problem. The system must also know where that text belongs, what it is allowed to change, and how to apply the result without damaging the rest of the article.

Selection-aware editing

The fastest editing workflow does not begin inside the copilot panel.

The author highlights a sentence or paragraph and chooses an action from the contextual toolbar:

Rewrite · Shorter · Proofread · Add citation

For example:

Rewrite

> Ever wondered what actually happens inside a Transformer?

Before the copilot opens, the editor stores the selected range. The model then returns an improved version, and the apply_selection_edit tool replaces that exact range.

The interaction works like this:

The author highlights text
The editor stores the selection range
The author chooses an action
The copilot receives the selected content
The model generates the requested revision
Forem replaces only the stored selection

Buddy does not need to be open before the author selects text.

The user also does not need to copy the response, return to the editor, find the original paragraph, paste the new version, and repair the formatting.

The change happens exactly where the writing already lives.

Draft-aware content insertion

Buddy also understands that different types of generated content belong in different places.

A title should update the title field.

Tags should become chips.

A TL;DR should appear near the top.

A new section should be inserted at the cursor or added to the end.

A full rewrite should replace the body only when the author clearly requests it.

This avoids one of the most common problems with generic AI writing tools: they generate useful content without understanding the structure of the product receiving it.

In my implementation, the model chooses the intended action, but Forem controls how that action is applied.

For example, the model can request:

{
  "tool":"insert_markdown",
  "position":"cursor",
  "content":"## How attention works\n\n..."
}

Or:

{
  "tool":"update_tags",
  "tags": ["ai","machinelearning","javascript","tutorial"
  ]
}

The client-side handler validates the request and updates the corresponding part of the editor.

Media generation inside the writing flow

I also wanted Buddy to handle tasks that normally require leaving the editor.

For Mermaid diagrams, the author can provide or select Mermaid syntax and ask Buddy to convert it into a PNG. The diagram is rendered, uploaded, and inserted back into the article as Markdown.

For article visuals, Buddy can generate a cover image or supporting image based on the title and draft context.

The goal is not merely to return an image prompt. The goal is to complete the usable workflow:

Understand what image the article needs
Generate or render the image
Make the result available to the article
Insert or assign it in the correct place

That is the difference between explaining how to add media and actually helping the author add it.

Automatic tags and TL;DR generation

Tags and summaries are small tasks, but they interrupt the final publishing flow.

Buddy can analyse the title and article body, select up to four relevant DEV tags, and populate the existing tag fields.

It can also generate a concise TL;DR and insert it at the top of the article using consistent Markdown:

## TL;DR

A concise summary of the article appears here.

The author can still edit or remove the result, but the mechanical work is already complete.

Architecture

Three processes:

Tools run against product state (DOM handlers for the form; later, APIs for member data). The model only emits tool names and arguments.
Runtime uses official SSE (server docs), not raw plain text.
Rails enforces session and CSRF. Model keys stay on the Node process.

Product-level extensions use the same spine. You change context and tools, not the overall shape.

How to split responsibilities

Long tool catalogs in the system prompt waste tokens and hurt tool choice. This split worked better:

Layer	Role
systemPrompt	Persona and product rules (e.g. title ≠ body H1)
tool descriptions	Short when/how (one sentence when possible)
`body()` each request	Live snapshot (`article_state`, later other `*_state`)
handlers	Validation and mutations
Skills (optional)	Process notes, not DOM writes

Attach draft state every turn; do not call “read draft” on every greeting.
Keep internal tool instructions out of the visible user message.

Then multi-part requests can become multiple tool calls in one turn (title + tags + body).

Setup on local Forem

Stack used: Forem + @yourgpt/copilot-sdk / @yourgpt/llm-sdk 2.5.x.

Prerequisites

Forem local environment (Ruby, Postgres, Redis, Node 20, Yarn)
Provider API key (Gemini used here)
Node runtime process alongside Rails

Packages

yarn add @yourgpt/copilot-sdk @yourgpt/llm-sdk openai

Environment

GOOGLE_API_KEY="…"
COPILOT_MODEL="gemini-3.6-flash"
COPILOT_FALLBACK_MODELS="gemini-3.5-flash-lite,gemini-3.5-flash,gemini-flash-lite-latest"
COPILOT_RUNTIME_URL="http://127.0.0.1:3101/api/copilot/stream"
COPILOT_RUNTIME_PORT=3101

Primary model: gemini-3.6-flash. Fallbacks help when the free tier returns 429.

Runtime

yarn copilot:runtime
curl -s http://127.0.0.1:3101/health

Per request: parse body → restore Gemini thought signatures when needed → stream via createRuntime.

Rails

post "/api/copilot", to: "copilot#chat"

Authenticate the user, proxy to COPILOT_RUNTIME_URL, stream text/event-stream, map failures to short messages. Do not show provider internals (e.g. thought_signature) in the UI.

Frontend

Mount node: #article-copilot-sdk-root
Pack: app/javascript/packs/copilotSdk.js
Keep CopilotProvider mounted when the dock is closed; only portal the panel when open. Selection actions need sendMessage without the dock.

<CopilotProvider
  runtimeUrl="/api/copilot"
  systemPrompt={SYSTEM_PROMPT}
  streaming
  maxIterations={12}
  headers={() => ({
    'X-CSRF-Token': csrfToken(),
    Accept: 'text/event-stream',
  })}
  body={() => ({ article_state: collectArticleState() })}
>
  <ArticleEditorTools />
  <SelectionToolbar onOpen={openDock} />
  {isOpen && createPortal(<BuddyPanel onClose={closeDock} />, document.body)}
</CopilotProvider>

Tools

Prefer JSON Schema on inputSchema, short descriptions, and { success: true/false, … } from handlers.

useTools({
  set_article_title: {
    description: 'Set the post title field (plain text, not markdown).',
    inputSchema: {
      type: 'object',
      properties: { title: { type: 'string' } },
      required: ['title'],
      additionalProperties: false,
    },
    handler: async ({ title }) => {
      const clean = cleanArticleTitle(title);
      const ok = setNativeValue(titleEl, clean);
      return { success: ok, title: clean, _aiResponseMode: 'brief' };
    },
  },
  insert_into_body: {
    description:
      'Insert body markdown (start|end|cursor). No leading H1; title is separate.',
  },
  apply_selection_edit: {
    description:
      'Replace selected body text once (Rewrite/Shorter). New text only; do not call again.',
    aiResponseMode: 'none',
  },
});

Strip a single leading # Title from body inserts so the title field is not duplicated.
On Rewrite/Shorter, store { start, end, text } before focus moves; clear after one successful apply to avoid retry loops.

CSS and build

@source "../../../node_modules/@yourgpt/copilot-sdk/dist/**/*.{js,ts,jsx,tsx}";

yarn build:copilot-css && yarn build

Checks

/health reports the configured model
Create Post shows the launcher when logged in
Tags update as chips
Title / tags / body update in the form, not only in chat
Selection Rewrite works with the dock closed first
Body does not start with a duplicate H1 title
Gemini tool follow-ups do not return 400

Piece	Path
UI	`app/javascript/article-form/components/CopilotSDK/index.jsx`
Tools	`…/ArticleEditorTools.jsx`
DOM	`…/editorDom.js`
Selection	`…/SelectionToolbar.jsx`
Tool UI	`…/ToolCards.jsx`
Runtime	`services/copilot-runtime/server.mjs`
Proxy	`app/controllers/copilot_controller.rb`
Pack	`app/javascript/packs/copilotSdk.js`

Docs: getting started · server · frontend tools · agentic loop · generative UI

Gemini 3 tool follow-ups

Gemini 3.x expects a thought signature on function calls for follow-up turns (docs, OpenAI compatibility):

"tool_calls": [{
  "id": "…",
  "type": "function",
  "function": { "name": "apply_selection_edit", "arguments": "{…}" },
  "extra_content": { "google": { "thought_signature": "…" } }
}]

If history is rebuilt without extra_content, the next request often fails with 400. Cache signatures by tool-call id while streaming, re-attach them on the next request, and normalize field names (tool_calls, tool_call_id). Prefer fixing that over permanently downgrading the model to avoid the issue.

Multi-tool turns also hit rate limits more easily on free tiers. Surface a clear retry message; optional fallback models help.

Small product choices that improved the feel

Toolbar messages: action label + quoted selection only
One apply per selection edit
Title in the title field; body without a leading H1
Short confirmation after tools
Keep title/tags/body tools available without deferred search on multi-step turns
Provider mounted whenever selection tools need sendMessage
User-facing errors without provider jargon

Extending the same Copilots beyond writing

The editor integration is one vertical. The reusable part is the loop:

Authenticated SSE
Context on every request
Tools that change real product state
Short chat around those tools

Other surfaces can reuse runtime + proxy + CopilotProvider. You swap the context object and the tool set.

Editor                         Extension surfaces
──────                         ──────────────────
article_state                  stats_state | reading_state | account_state
set_article_title              summarize / list tools (read)
fill_tags                      pin_list / update_pref (write, often with confirm)
insert_into_body               navigate / open section
apply_selection_edit

I did not fully implement stats, reading-list, or settings copilots. Below is a practical map so someone continuing from this work knows what to add.

Rules that still apply

Rule	Reason
Put live data in `body()`, not a mandatory “read all” tool every turn	Fewer wasted tool rounds
Tools only perform actions the member can already perform	Matches product permissions
Keep tool descriptions short	Better tool choice, smaller schemas
Keep user-visible messages free of internal instructions	Clearer chat
Prefer one-shot mutations where possible	Avoid loops
Confirm destructive or account-wide changes	Especially settings
Never put secrets in model context	Tokens, passwords, raw session ids

Stats

Goal: explain numbers the member can already see, and suggest a next writing step from real data—not invented metrics.

Context example:

body: () => ({
  surface: 'dashboard',
  stats_state: {
    range: '30d',
    totals: { views, reactions, comments, followers_delta },
    top_posts: [{ id, title, views, reactions, published_at }],
    series: [{ date, views }],
  },
})

Example tools: get_stats_snapshot, list_top_posts, open_post_analytics, suggest_followup_topics (text only from provided posts), optional bridge to editor tools for an outline.

Example questions: why views changed; which posts to turn into a series; what to write next given top tags.

Constraint: if a figure is not in context or a tool result, say so. Do not invent analytics.

Reading list

Goal: build a short, personal queue from real posts (search/save/follow APIs), not hallucinated links.

Context example: followed tags, recent reads, saves, optional goals.

Example tools: search_posts, build_reading_list, pin_reading_item, save_for_later, follow_tag / mute_tag (with confirmation), export_reading_list.

Example questions: weekend list on a topic; next reads based on history; pin three and drop already-read items.

Constraint: every recommended URL/id should come from a tool or injected state.

Account and settings

Goal: explain settings and, where safe, apply changes the member already has UI for—without dumping secrets into the prompt.

Context example: profile completeness flags, notification toggles, 2FA on/off, session count—not passwords or raw tokens.

Example tools: open_settings_section, update_notification_pref (confirm), update_profile_field (confirm for public fields), list_sessions, revoke_session (confirm), explain_setting (read-only).

Example questions: reduce email noise; complete public profile; review sessions.

Constraint: prefer navigate + explain by default; mutate only with confirmation (needsApproval or equivalent). Stricter than the editor.

Implementation order for an extension

Choose one surface.
Define a *_state payload you can collect safely.
Add a small tool pack (about 4–8 tools) with short descriptions.
Mount CopilotProvider on that page; pass surface + state in body().
Reuse the existing runtime and Rails proxy.
Adjust the system prompt for that surface only.
Test normal prompts and refusal cases (“delete my account” without a tool, etc.).
Optionally connect back to the editor (e.g. stats → outline → insert_into_body).

Prompt for an AI coding agent

Paste this into Cursor, Claude Code, Codex, or similar when you want the agent to set up the same stack on a Forem (or similar) codebase:

You are implementing an editor-aware writing copilot on Forem using the YourGPT Copilot SDK
(@yourgpt/copilot-sdk + @yourgpt/llm-sdk ~2.5.x), matching this architecture:

ARCHITECTURE
- Browser: CopilotProvider (always mounted) + useTools handlers + SelectionToolbar
  + CopilotChat portaled in a right dock when open
- Rails: authenticated POST /api/copilot streams SSE to the Node runtime (CSRF + session)
- Node: services/copilot-runtime/server.mjs with createRuntime, Gemini 3.x primary model
  (COPILOT_MODEL=gemini-3.6-flash), thought_signature cache/restore on tool follow-ups,
  optional model fallbacks on 429
- Never put API keys in the client. Never stream text/plain to CopilotChat.

DOCS (prefer over memory)
- https://copilot-sdk.yourgpt.ai/docs/getting-started
- https://copilot-sdk.yourgpt.ai/docs/server
- https://copilot-sdk.yourgpt.ai/docs/tools/frontend-tools
- https://copilot-sdk.yourgpt.ai/docs/tools/agentic-loop
- https://copilot-sdk.yourgpt.ai/docs/generative-ui
- https://ai.google.dev/gemini-api/docs/thought-signatures

FILE MAP TO CREATE/UPDATE
app/javascript/article-form/components/CopilotSDK/
  index.jsx, SelectionToolbar.jsx, ArticleEditorTools.jsx, editorDom.js,
  ToolCards.jsx, toolSchemas.js
app/javascript/packs/copilotSdk.js
app/assets/stylesheets/copilot-sdk.css  (Tailwind @source SDK dist; FAB + dock + selection pill)
app/controllers/copilot_controller.rb
config/routes.rb → post "/api/copilot"
services/copilot-runtime/server.mjs
.env: GOOGLE_API_KEY, COPILOT_MODEL, COPILOT_RUNTIME_URL, COPILOT_FALLBACK_MODELS

UI REQUIREMENTS (match this UX)
- Floating launcher (avatar + BETA badge) bottom-right above article actions
- Right full-height dock (~400px) with official CopilotChat (csdk-theme-modern)
- Provider ALWAYS mounted; only dock portals when open; body class buddy-dock-open
- Selection toolbar on body highlight: Rewrite + Shorter only (no internal prompts in chat)
- User message format: "Rewrite\n\n> selected text" (blockquote). Tool policy in system
  prompt + tool descriptions, not in the bubble
- On toolbar click: setPendingBodySelection({start,end,text}), open dock, sendMessage
- apply_selection_edit once using pending range; clear pending; do not loop
- Live article_state (title, tags, body) in CopilotProvider body() every request
- Strip leading H1 from body inserts; title is a separate plain-text field
- Short friendly parseError messages; never show thought_signature to users
- toolRenderers for tags/cover/mermaid/TL;DR; ToolStep titles for simple tools
- local thread persistence key: dev-community-buddy-threads

TOOLS (inputSchema JSON Schema, short descriptions)
set_article_title, fill_tags, insert_into_body, replace_article_body,
apply_selection_edit (eager, one-shot), generate_tldr, generate_cover_image,
mermaid_to_png; optional get_article_draft (not on every greeting)

LAYERING
systemPrompt = persona + product rules only (no tool catalog)
tool descriptions = short decision boundaries
body() = live state
handlers = DOM mutations, return { success, ... }

VERIFY
yarn build:copilot-css && yarn build
yarn copilot:runtime → curl health
Logged-in Create Post: launcher, tags chips, multi-tool title+tags+body,
selection Rewrite with dock closed first, no body H1 title, no 400 on tool follow-up

If something fails, fix signatures / selection pending range / Provider mount first—
do not downgrade Gemini major solely to hide tool-follow-up 400s unless the user asks.

FAQ

Is this the official DEV Community Buddy?

No. This is an independent fan-built experiment using Forem. It is not affiliated with, endorsed by, or deployed by DEV.to Community. I built it to explore a more efficient and action-capable version of Buddy could look like, especially one that can understand the article context, work directly with the editor, and help developers write and publish with less manual effort.

Why did you build it on Forem?

DEV Community at dev.to is built on Forem, its open-source community platform. After testing the first beta version of DEV Community Buddy, I found it useful for basic writing guidance, but it still behaved more like a chatbot than an integrated product copilot. I wanted to explore a more capable experience that could help developers write better posts with less manual work, so I ran the same Forem foundation behind dev.to locally and connected it to the YourGPT Copilot SDK. The SDK made it possible to turn Buddy into an action-capable copilot that understands the live article state and can safely interact with the real writing interface. Instead of only suggesting text, it can update the title, fill relevant tags, rewrite or proofread selected content, insert a TL;DR, generate images, convert Mermaid diagrams into PNGs, add citations, and place Markdown in the correct location. This allowed me to build a more contextual and efficient writing workflow inside the actual product, rather than a separate AI demo that could not operate the editor.

What part of the project is actually implemented?

The editor copilot is implemented. It can work with the title, tags, article body, selected text, cursor position, TL;DR generation, Mermaid rendering, and media-related actions.

The stats, personalised reading list, account, and settings copilots are proposed extensions of the same architecture. They are not presented as completed features.

What is the YourGPT Copilot SDK?

The YourGPT Copilot SDK is an open-source framework for building AI copilots that can understand product context, use tools, and take actions inside an application. It provides the client components and runtime infrastructure for streaming conversations, frontend and backend tool execution, live application context, multi-step agent workflows, and generative UI. Rather than adding a standalone chatbot, it helps developers build a agentic copilot that is embedded into the product experience and can safely operate within the actions and permissions the application exposes.

Why use the YourGPT Copilot SDK instead of calling a model API directly?

A direct LLM API can generate text, but it does not automatically make an application agentic. The YourGPT Copilot SDK adds the orchestration layer required to build an action-capable AI copilot agent inside a product. It streams responses, passes live application context such as the current article title, tags, body, cursor position, and selected text, connects the model to controlled frontend tools, supports multi-step tool execution, and renders tool progress directly in the interface. This allows the copilot to do more than suggest content. It can safely update fields, replace selected text, insert Markdown, generate media, and complete approved actions on the user’s behalf. The core value of the SDK is not access to a particular AI model, but the infrastructure for turning model output into contextual, permissioned product actions.

Can I use a different model?

Yes. The architecture is model-independent. Gemini was used for this implementation, but another supported provider can be configured through the runtime.

Why did you use Gemini for this build?

Gemini was the primary model used while developing and testing the integration. It supported the tool-calling and image gen workflow needed for editor actions.

Why use frontend tools for editor actions?

The relevant state already exists in the browser, including the current selection, cursor position, unsaved body content, and focused field.

Frontend tools can operate on that live state without repeatedly saving the draft or sending unnecessary requests to the backend. Server-side tools are still more appropriate for protected data, external services, uploads, and account-level actions.

How does the copilot know what is in the current draft?

The application passes a structured article-state object with each request. It can include the title, tags, body, selected text, cursor position, and active surface.

This gives the AI current product context without requiring the author to paste the article into the conversation.

Can the copilot modify anything in the application?

Yes, Copilot can take action on an application by using the exposed tools.

Can this architecture work outside the DEV editor?

Yes. The same runtime, authenticated proxy, provider, and tool pattern can support other product surfaces.

For example:

Analytics explanations using stats_state
Personalised reading lists using real post-search tools
Navigation and account assistance
Notification preference management
Profile updates with confirmation

The main changes are the context object, available tools, and permission rules.

Is the YourGPT Copilot SDK limited to React applications?

The client components used in this implementation are React-based, but the broader architecture is not limited to a particular backend. The runtime and tool pattern can be integrated with applications using Rails, Node, or other server environments.

The exact frontend integration depends on how the host application exposes state and actions.

Can this be used in production?

Absolutely. Both Forem and the YourGPT Copilot SDK are open source, so you can clone the repositories, fork them, modify the code, self-host the complete stack, and adapt this implementation for your own product. The YourGPT Copilot SDK is available under the permissive MIT License, while Forem is released under the GNU Affero General Public License v3.0

Closing

I wanted to build a copilot that understands a draft as live product state, not just text inside a chat window. It should know the title, tags, body, cursor position, and selected text, choose from a controlled set of tools, apply the requested change in the correct place, and stop once the editor has been updated.

That is what I built on a local Forem instance. The process also exposed the less visible problems behind an action-capable copilot: preserving selections after focus changes, preventing repeated tool execution, avoiding duplicate H1 titles, handling provider-specific tool follow-ups, and recovering cleanly from rate limits.

The same architecture can extend beyond writing. By changing the context and available tools, the copilot could explain article performance, curate a personalised reading list, navigate product settings, or complete other approved actions across the platform.

Forem’s open-source foundation made the experiment possible. The YourGPT Copilot SDK provided the agentic application layer for streaming, context, tool execution, and product actions. I have included the architecture, implementation notes, checks, and extension paths so other developers can reproduce the editor integration, improve it, or adapt the same pattern to their own products.

The larger lesson is simple: adding a chat panel gives users answers. Connecting an AI copilot to real product state and controlled tools gives them outcomes.

The Great AWS Outage of October 2025: When the Internet's Backbone Buckled

SupermanSpace — Mon, 20 Oct 2025 19:03:41 +0000

October 20, 2025 — In the early hours of Monday morning, millions of internet users worldwide woke up to find their favorite apps and services completely unavailable. Snapchat wouldn't load. Wordle was inaccessible. Medium not loading. Vercel was not working. Ring doorbells went dark. Amazon's own shopping site displayed error pages featuring apologetic dog photos. The culprit? A massive outage at Amazon Web Services (AWS), the cloud computing giant that quietly powers much of the modern internet.

The Scale of the Disruption

The outage began at 12:11 a.m. PT (3:11 a.m. ET) when AWS reported an "operational issue" affecting 14 different services in its U.S.-East-1 Region center in northern Virginia. What started as a technical glitch in a single data center quickly cascaded into one of the largest internet disruptions since the CrowdStrike malfunction of 2024.

Over 4 million users reported issues due to the incident, affecting an astonishing array of services that people rely on daily. The impact was both widespread and democratic in its chaos, bringing down everything from entertainment platforms to critical business infrastructure.

Who Was Affected?

The list of affected services reads like a who's who of the internet:

Social Media & Communication:

Snapchat
Reddit
Signal (encrypted messaging)

Gaming:

Fortnite
Roblox
Pokémon GO

Financial Services:

Coinbase (cryptocurrency exchange)
Venmo
PayPal
Robinhood
Chime

Amazon's Own Services:

Amazon.com (shopping)
Prime Video
Alexa
Ring doorbells and security cameras

Airlines:
United Airlines experienced disruptions to its app and website, with some internal systems also temporarily affected. Delta Airlines experienced a small number of minor flight delays.

Education:

Duolingo
Canvas (online teaching platform)

Other Major Services:

Canva (graphic design)
Perplexity (AI search)
Max (streaming)
Apple Music
Microsoft Teams (surprisingly affected despite Microsoft's own Azure cloud)

Support

Intercom (down from last 11 hours)
YourGPT Helpdesk (not loading for 15 minutes)
Ada (not working for 2 hours)

In the United Kingdom, customers of banks including Lloyds, Bank of Scotland, and Halifax reported issues while attempting to log into their accounts. British government websites Gov.uk and HM Revenue and Customs also experienced disruptions, highlighting
how critical infrastructure has become dependent on cloud services.

The Root Cause: A DNS and Database Perfect Storm

At 4:26 a.m. ET, Amazon flagged significant error rates for requests made to the DynamoDB endpoint in the US-EAST-1 Region. DynamoDB is AWS's database service that thousands of companies use to manage their data tables and indexes.

The issue appeared to be related to DNS resolution of the DynamoDB API endpoint. DNS (Domain Name System) is essentially the internet's phonebook, translating human-readable website names into computer-readable IP addresses. When this system fails to communicate with databases, the entire chain of services collapses.

At 11:43 a.m., AWS identified the root cause as "an underlying internal subsystem responsible for monitoring the health of our network load balancers". This technical fault in a monitoring system created a cascading failure that rippled through AWS's entire infrastructure.

A software engineer and cyber expert noted that the issue appeared to be with one of the networking systems AWS uses to control a database product, highlighting how a problem in one small component can bring down an entire ecosystem.

The Recovery: A Long and Bumpy Road

At 6:35 a.m. ET, AWS announced that the database problem was "fully mitigated" but warned there may still be delays. However, the recovery proved more complicated than initially hoped.

Many sites came back online within a few hours, although Downdetector showed another spike in user reports around noon ET of outages at Amazon, AWS and Alexa. The initial fix didn't fully resolve all issues, and services continued to experience intermittent problems throughout the day.

Around 1:30 p.m. ET, AWS said it was starting to see "early signs" of EC2 recovery in some regions and was applying fixes to remaining areas. The company's EC2 (Elastic Compute Cloud) service provides virtual server capacity that companies rely on to run their applications.

Amazon.com itself wasn't spared from the chaos. Reports on Downdetector showed over 12,000 outages in the US, with Amazon displaying "something went wrong" error pages featuring various dogs to frustrated shoppers.

Real-World Impact: Beyond Inconvenience

While many users experienced mere inconvenience, the outage had more serious consequences for others:

Business Disruption: Warehouse and delivery employees, along with drivers for Amazon's Flex service, reported that internal systems were offline at many sites. Some warehouse workers were instructed to stand by in break rooms and loading areas during their shift.

Accessibility Concerns: One user shared a particularly poignant example of how cloud dependency affects vulnerable populations: "I use Alexa-enabled smart plugs to control the lamps in my room. I'm unable to walk without leaning on crutches so being able to turn lights and music on by voice is very helpful. During the outage my smart plugs became unresponsive".

Educational Impact: Educational publishing company Folens contacted teachers advising that services linked to its 'My Folens' library were being disrupted, affecting students' access to learning materials.

Security Concerns: Ring experienced outages affecting thousands of users, creating problems for those who rely on Ring doorbells and security cameras for safety.

The Fragility of Centralized Infrastructure

This outage underscores a fundamental vulnerability in how the modern internet is structured. The outage highlighted the fragility of companies that use cloud-based servers to host their data, and how suddenly businesses across the globe can be affected by an unplanned outage.

AWS is the dominant player in cloud computing, making $107 billion in the 2024 financial year, representing 17% of Amazon's total revenue. This dominance means that when AWS experiences problems, the ripple effects are felt globally.

Cori Crider, executive director of the Future of Technology Institute, stated: "Europe's dependency on monopoly cloud companies like Amazon is a security vulnerability and an economic threat we can't ignore", calling for European governments to diversify their cloud providers and support local alternatives.

Charlotte Wilson, head of enterprise at Check Point Software Technologies, noted: "Today's outage is another reminder that the digital world doesn't stop at borders - a local fault can ripple worldwide in minutes".

Was It a Cyberattack?

With such widespread disruption, speculation naturally turned to the possibility of malicious activity. However, Rob Jardin, chief digital officer at cybersecurity company NymVPN, stated: "There's no sign that this AWS outage was caused by a cyberattack - it looks like a technical fault affecting one of Amazon's main data centres".

Rafe Pilling, director of threat intelligence at cybersecurity firm Sophos, acknowledged: "When anything like this happens, the concern that it's a cyber incident is understandable. AWS has a far-reaching and intricate footprint, so any issue can cause a major upset". However, all evidence points to a technical failure rather than malicious intent.

Lessons Learned and Moving Forward

This incident raises critical questions about internet infrastructure resilience:

Single Points of Failure: The concentration of so many services on a single cloud provider creates systemic risk. When AWS goes down, significant portions of the internet follow.
Redundancy vs. Cost: While AWS and other cloud providers generally maintain robust systems, the complexity of these networks means that unforeseen interactions can cause cascading failures.
Transparency: AWS customers were unable to report the problem because its automated support ticketing system was also offline, highlighting how even reporting mechanisms can be caught in the same failure.
Geographic Concentration: Many outages appeared to be concentrated in the United States, with a focus in Virginia, which is considered the global capital for data centres, demonstrating the risks of geographic concentration.

The Aftermath

As of late Monday afternoon, AWS continued working toward full resolution, with most services gradually returning to normal operation. However, the incident serves as a stark reminder of how dependent modern life has become on cloud infrastructure.

Charlotte Wilson recommended that people keep good backups, save important information offline, and know alternative ways to connect to the internet or pay if systems fail — practical advice for an increasingly cloud-dependent world.

The AWS outage of October 2025 will likely be studied for years to come as a case study in infrastructure fragility, centralization risk, and the need for more resilient digital systems. As we continue to move more of our lives online, building redundancy and diversification into our digital infrastructure isn't just good engineering — it's essential for maintaining the connectivity that modern society depends upon.

For now, the internet has largely recovered, but the question remains: how do we build a more resilient digital future that doesn't collapse when a single provider stumbles?

This is a developing story. AWS continues to monitor services and work toward complete restoration of all affected systems.

What Two Years of Bootstrapping an AI Startup in India Taught Us

SupermanSpace — Mon, 18 Aug 2025 08:20:00 +0000

When we started in 2023, our mission was simple: help businesses build with AI.

Our first product was a fine-tuning tool for businesses to customise AI models. At the time, fine-tuning was resource-heavy & challenging.

Fine-tuning required preparing datasets (and even synthetic data generation was not as highly feasible as today), running heavy compute, and testing multiple iterations to avoid issues like overfitting or underfitting. In practice, this meant months of work and high costs—something only big tech firms could manage.

We saw this gap. Instead of making everyone rebuild models, we introduced advanced RAG-based AI chatbots that could train on a company’s own data while using existing models. RAG allowed companies to use powerful existing models while still grounding answers in their own data—giving them customisation without the cost of fine-tuning*.*

As we worked with more customers it became clear that most businesses did not want multiple tools. They wanted one solution that could handle conversations, support teams, help them grow, and actually grow with them.

We realised many teams face the same challenge: managing multiple disconnected systems slows them down. We combined our fine-tuning capabilities with the YourGPT Chatbot for enterprise users who still need customised models, while also building a single platform for conversations, training, and automation so teams no longer have to juggle separate tools.

We are a small, fast-moving team bootstrapped from day one. We learn by shipping, watching, and listening. Over time every feature we built, from the action-oriented Copilots builder to AI Agents to AI Studio, Helpdesk, Voice Agents was brought together in one product: YourGPT.

It’s been a pleasure building our product from Mohali, India.

With a lean, customer-focused team, we help businesses unlock value and maximize innovation. One big lesson: hire for mindset. India has incredible talent, and we now prioritize curiosity, passion, and ownership over resumes—skills can be taught, but hunger to solve problems can’t.

We also learned that partnerships matter as much as technology. As developers we love to build, but growing a business is more than code. Relationships with customers, vendors, and other startups help keep the momentum going. If someone has ideas or wants to discuss potential collaborations, they can reach us at pr@yourgpt.ai.

For other bootstrapped builders, here is one thing I wish I had known earlier, and I am sharing it in case it helps you too:Focus on one strong product. Do not get distracted by vibe coding, which will scatter your efforts across too many directions. Grow one vertical well and then expand it horizontally. This creates more value for your users and makes your product journey clearer.

Two years in, our focus is clear: help businesses automate support, sales, and operations, and scale with AI.

Real progress comes from building, shipping, and learning.

Bootstrapping taught us this: momentum matters more than money. Keep building.

These are lessons we continue to learn every day. If you are building something now, what is the one challenge slowing you down the most?

Elevenlabs text to speech unity

SupermanSpace — Thu, 01 Aug 2024 13:49:06 +0000

Get Voice ID

using System;
using System.Net.Http;
using System.Threading.Tasks;
using UnityEngine;
using Newtonsoft.Json.Linq; // Make sure you add the Newtonsoft.Json package via Unity Package Manager

public class VoiceFetcher : MonoBehaviour
{
    private const string XiApiKey = "<xi-api-key>"; // Your API key

    // URL for the API endpoint
    private static readonly string Url = "https://api.elevenlabs.io/v1/voices";

    // Start is called before the first frame update
    private async void Start()
    {
        await FetchAndPrintVoices();
    }

    private static async Task FetchAndPrintVoices()
    {
        using (var client = new HttpClient())
        {
            // Set up headers for the API request, including the API key for authentication
            client.DefaultRequestHeaders.Add("Accept", "application/json");
            client.DefaultRequestHeaders.Add("xi-api-key", XiApiKey);
            client.DefaultRequestHeaders.Add("Content-Type", "application/json");

            try
            {
                // Send GET request to the API endpoint
                var response = await client.GetAsync(Url);

                // Check if the request was successful
                if (response.IsSuccessStatusCode)
                {
                    // Read and parse the JSON response
                    var jsonResponse = await response.Content.ReadAsStringAsync();
                    var data = JObject.Parse(jsonResponse);

                    // Loop through each voice and print the name and voice_id
                    foreach (var voice in data["voices"])
                    {
                        string name = voice["name"].ToString();
                        string voiceId = voice["voice_id"].ToString();
                        Debug.Log($"{name}; {voiceId}");
                    }
                }
                else
                {
                    // Print error message if the request was not successful
                    Debug.LogError($"Error fetching voices: {await response.Content.ReadAsStringAsync()}");
                }
            }
            catch (Exception e)
            {
                // Print any exceptions that occur
                Debug.LogError($"Exception occurred: {e.Message}");
            }
        }
    }
}

Text to speech

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using UnityEngine;

public class TextToSpeech : MonoBehaviour
{
    // Constants for the script
    private const int ChunkSize = 1024; // Size of chunks to read/write at a time
    private const string XiApiKey = "<xi-api-key>"; // Your API key for authentication
    private const string VoiceId = "<voice-id>"; // ID of the voice model to use
    private const string TextToSpeak = "<text>"; // Text you want to convert to speech
    private const string OutputPath = "output.mp3"; // Path to save the output audio file

    // URL for the Text-to-Speech API request
    private static readonly string TtsUrl = $"https://api.elevenlabs.io/v1/text-to-speech/{VoiceId}/stream";

    // Start is called before the first frame update
    private async void Start()
    {
        await FetchAndSaveAudio();
    }

    private static async Task FetchAndSaveAudio()
    {
        using (var client = new HttpClient())
        {
            // Set up headers for the API request, including the API key for authentication
            client.DefaultRequestHeaders.Add("Accept", "application/json");
            client.DefaultRequestHeaders.Add("xi-api-key", XiApiKey);

            // Set up the data payload for the API request, including the text and voice settings
            var data = new
            {
                text = TextToSpeak,
                model_id = "eleven_multilingual_v2",
                voice_settings = new
                {
                    stability = 0.5,
                    similarity_boost = 0.8,
                    style = 0.0,
                    use_speaker_boost = true
                }
            };

            // Serialize the data payload to JSON
            var content = new StringContent(JsonUtility.ToJson(data), System.Text.Encoding.UTF8, "application/json");

            // Make the POST request to the TTS API with headers and data, enabling streaming response
            using (var response = await client.PostAsync(TtsUrl, content, HttpCompletionOption.ResponseHeadersRead))
            {
                if (response.IsSuccessStatusCode)
                {
                    // Open the output file in write-binary mode
                    using (var fileStream = new FileStream(OutputPath, FileMode.Create, FileAccess.Write, FileShare.None))
                    {
                        // Read the response in chunks and write to the file
                        using (var responseStream = await response.Content.ReadAsStreamAsync())
                        {
                            var buffer = new byte[ChunkSize];
                            int bytesRead;
                            while ((bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
                            {
                                fileStream.Write(buffer, 0, bytesRead);
                            }
                        }
                    }
                    // Inform the user of success
                    Debug.Log("Audio stream saved successfully.");
                }
                else
                {
                    // Print the error message if the request was not successful
                    Debug.LogError(await response.Content.ReadAsStringAsync());
                }
            }
        }
    }
}

This is a affiliate link, if you like you can contribute for free https://try.elevenlabs.io/7okdawkpiqom

If you want you can sponsor our writing partners:
https://buymeacoffee.com/clubwritter

Discord AI Bot with Cohere LLM Integration

SupermanSpace — Sat, 27 Jul 2024 14:21:54 +0000

Hey everyone,

A few months ago, I worked on a Discord bot that uses the Cohere API. I’m now happy to share the source code with you all.

The bot responds to commands and mentions in a Discord server, and it interacts with the Cohere API to generate responses. If you're looking to build a similar bot or just want to see how it’s done, you can check out the code below.

Feel free to use it as a base for your own projects or to learn how to integrate Discord with an LLM. Click below image to download the code 👇

The Github has been Shadow banned :)

Replace your-cohere-api-key and your-discord-bot-token with your actual API key and bot token.

I will Update this Blog soon.

What More You Can Add:

Emoji Reactions Based on Message Classification:

Feature: Add functionality to react with emojis based on the sentiment or content classification of the user’s message.

Custom Command Handling:

Feature: Allow users to define custom commands and responses in the Discord server.

Hope you find it useful! If you do,You can consider supportting author on Patreon 🎉 and Ko-fi ☕.

Drop your comments down, that will motivate us to share more personal projects.

GPT4omnini mini is Now Publicly available

SupermanSpace — Thu, 18 Jul 2024 18:13:03 +0000

It is 60% cheaper and better than GPT 3.5 turbo😏.

What you are building with it?

Create Folder Structure using LLM

SupermanSpace — Sun, 14 Jul 2024 12:29:00 +0000

I wanted to share an update on a project I worked on some time ago. I've made some changes to the code for creating project structures using LLM. Here’s the code:

import json
import os
import cohere

# Initialize the Cohere client with a more secure approach
co = cohere.Client(api_key='YOUR_COHERE_KEY')

def create_project_structure(structure, base_path="/content/"):
    """
    Create a directory and file structure based on a nested dictionary.
    """
    try:
        for folder, files in structure.items():
            folder_path = os.path.join(base_path, folder)
            os.makedirs(folder_path, exist_ok=True)
            for file_name, content in files.items():
                file_path = os.path.join(folder_path, file_name)
                if isinstance(content, dict):
                    create_project_structure(content, base_path=folder_path)
                else:
                    with open(file_path, "w") as file:
                        file.write(content)
        return "Project structure created successfully."
    except Exception as e:
        return f"An error occurred: {str(e)}"

# JSON schema for the function argument
tools = [{
    "name": "create_project_structure",
    "description": "Create an entire project structure with specified files and contents.",
    "parameter_definitions": {
        "structure": {
            "description": "Dictionary specifying folders and files with their contents.",
            "type": "dict",
            "required": True
        },
        "base_path": {
            "description": "Base path where the project structure will be created.",
            "type": "str",
            "required": False
        }
    }
}]

functions_map = {
    'create_project_structure': create_project_structure
}

# Placeholder for example user request and handling
message = "write complete flappy bird game using unity"
preamble = """
## Task & Context
Answer questions and handle requests on a variety of topics using appropriate tools and research methods.

## Style Guide
Respond in full sentences, using proper grammar and spelling, unless requested otherwise.
"""

# Simulate handling a user request
response = co.chat(
    message=message,
    tools=tools,
    preamble=preamble,
    model="command-r",
    force_single_step=True
)

# Process and execute the recommended tool calls
tool_results = []
for tool_call in response.tool_calls:
    output = functions_map[tool_call.name](**tool_call.parameters)
    tool_result = {
        "name": tool_call.name,
        "parameters": tool_call.parameters,
        "outputs": [output],
        "call": tool_call
    }
    tool_results.append(tool_result)

print("\nTool execution results:\n")
print(json.dumps(tool_results, indent=4))

# Handle the final response using the results from tool calls
final_response = co.chat(
    message=message,
    tools=tools,
    tool_results=tool_results,
    preamble=preamble,
    model="command-r",
    temperature=0.3,
    force_single_step=True
)

print("Final answer:")
print(final_response.text)

Tweak it for your needs and best of luck 🤞

If you'd like to support my work, consider checking out my Patreon: Superman Space.

Emailing Hacks you might want to know - 🥶 Cold Marketing

SupermanSpace — Sat, 13 Jul 2024 19:45:34 +0000

As developers, we often find ourselves needing to reach out to potential clients, collaborators.

Cold emailing can be a powerful tool to achieve this,

Do you use other methods besides cold marketing? If so, share them in the comments.

But it requires a strategic approach. Here are some key takeaways from my experience:

Personalize Your Emails: It’s not enough to just use someone’s name. Dig into their work and mention specific details. This shows you’ve done your homework.
Be Concise and Clear: People don’t have time for long emails. Get to the point quickly and clearly.
Strong Subject Lines: You think questions and numbers in subject lines grab attention?
Effective Follow-Ups: Don’t just send one email and hope. Follow up strategically.
Use a Clear Call-to-Action:
This could be a request for a meeting or a proposal. Make it easy for the recipient to respond.
Timing:
Right time deliveribility make it more likely to get more acknowledgement.

These tweaks can make a big difference in response rates. For a complete guide, check post i wrote for Clubwritter.

OpenAI's launch TakeAway

SupermanSpace — Tue, 14 May 2024 09:26:52 +0000

OpenAI has launched GPT-4o, an advancement in AI technology. Here’s quick highlight you need to know:

Key Features:

The Image shows the Benchmark Score

Multimodal Capabilities: GPT-4o can understand and generate responses across audio, vision, and text. O stands for omni.
Real-time Reasoning: Offers improved real-time reasoning for diverse applications.
Advanced Interactivity: Enhances user interaction with more natural and dynamic conversations.

Launch Highlights:

Announced in May 2024 as part of OpenAI's Spring Update.
Free tools and capabilities are now available for ChatGPT users.
ChatGPT For Desktop

Know more about GPT-4o by visiting OpenAI’s official announcement.

Share your thoughts below! And excited about today's Google launch?

YourGPT Launches Chatbot Studio: Key Takeaways

SupermanSpace — Thu, 29 Feb 2024 16:06:17 +0000

Today, YourGPT rolled out Chatbot Studio.

Chatbot Studio is a flow builder that allows to create advanced conversational AI agents. It includes features like detecting message intents to guide interactions, making calls to third-party APIs, responding interactively with elements such as images, carousels, and buttons, allowing human intervention through actions, and enabling customization of conversations with JavaScript code, among other capabilities.

Key Takeaways from the Chatbot Studio Release:

Visual Flow Editor: The creation of Conversational AI Agents through a visual editor by connecting nodes, making them accessible to users without coding expertise.
Enhanced Interaction Tools: Offers advanced features like API calls, dynamic content (carousels, cards, buttons), and intent detection for richer user interactions.
Real-Time Testing and Deployment: Integrated emulator for testing conversational flows in real-time, ensuring a polished user experience upon deployment.
Advanced Customisation: Supports custom JavaScript code execution for custom functionalities, serving to specific needs.
Pre-built Templates: Provides a variety of industry-specific templates (e-commerce, healthcare, real estate, travel, banking) for a quick and efficient setup.

Which features do you like the most? Share them in Comments!

What do you want Me to Cover

SupermanSpace — Tue, 16 Jan 2024 18:24:51 +0000

Tell me in below comments that what should I cover and share with you About AI, Prompting, Programming, side Hustle or Game Development.

Hows Yours Weekends 😁

SupermanSpace — Sun, 14 Jan 2024 16:40:07 +0000

Hi 👋, This post is little casual how's your weekends?

Mine is quick and Short weekend, huh? 😁 Getting set for Monday morning – gearing up for the week?

How about yours ?

                   Tell in comments.