You'll also discover over time which systems the AI can handle fine on its own and which abstractions and systems it just has no ideas on how to design. Often I find I have no idea how to design those too. It's then useful to try different designs, test tradeoffs and refactor aggressively if needed.

Comments URL: https://news.ycombinator.com/item?id=50069079

Points: 1

# Comments: 0

When an agent fails at step 9 of 12, how do you handle that?

Roughly how many engineer-weeks have you sunk into agent infrastructure (durability, monitoring, human-in-the-loop, live UI) vs. the actual agent logic? Curious if my ratio is normal.

For those who built this stuff in-house: was it ever a build-vs-buy conversation? What would a tool have had to do for you to buy instead of build?

Do you currently pay for anything in your agent stack (LangSmith, Temporal, Braintrust, etc.)? What made that one worth a line item when others weren't and should I look into it too?

Comments URL: https://news.ycombinator.com/item?id=48342441

Points: 12

# Comments: 7

Github (MIT license): https://github.com/yail259/overnight Landing Page: https://workovernight.com/

What makes it different to all the other generic “run Claude Code while you sleep” ideas is the insight that every developer works differently, and rather than a generic agent or plan that gives you mediocre, generic results, the manager/supervisor AI should behave the way you would’ve behaved and tried to continue like you to focus on the things you would’ve cared about.

The first time you run Overnight, it’ll try to scrape all your Claude Code chat history from that project and build up a profile of you as well as your work patterns. As you use Overnight and Claude Code more, you will build up a larger and more accurate profile of how you prompt, design and engineer, and this serves as rich prediction data for Overnight to learn from execute better on your behalf. It’s designed so that you can always work on the project in the day to bring things back on track if need be and to supplement your workflow.

The code is completely open source and you can bring your own Anthropic or OpenAI compatible API keys. If people like this project, I’ll create a subscription model for people who want to run this on the cloud or don’t want to manage another API key.

All of overnights work are automatically committed to new Git branches so when you wake up, you can choose to merge or just throwaway its progress.

It is designed with 4 modes you can Shift Tab through depending on how adventurous you are feeling:

1. tidy — cleanup only, no functional changes. Dead code, formatting, linting. 2. refine — structural improvement. Design patterns, coupling, test architecture. Same features, better code. 3. build — product engineering. Reads the README, understands the value prop, derives the next feature from the business case. 4. radical — unhinged product visionary. "What if this product could...?" Bold bets with good engineering. You wake up delighted or terrified. Hope you like this project and find it useful!

Comments URL: https://news.ycombinator.com/item?id=47501042

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=47286526

Points: 1

# Comments: 0

It’s open source, written in TypeScript, and lets you structure your game logic almost like a single-player project while the library handles state syncing. It provides first-class Phaser support and aims to be much simpler than alternatives like Colyseus or Nakama.

I’m a hobby game developer and would appreciate feedback, criticism, or suggestions from the community.

Comments URL: https://news.ycombinator.com/item?id=46159685

Points: 1

# Comments: 0

The frustrating part was that these bugs only showed up with multiple real players. Can't reproduce them locally, can't easily test fixes, and adding logging changes the timing enough that bugs disappear.

After rebuilding networking code for the third time across different projects, I noticed something: most multiplayer bugs come from thinking about networking instead of game logic.

## The approach

In single-player games, you just write: ```typescript player.x += velocity.x; player.health -= 10; ```

So I built martini-kit to make multiplayer work the same way:

```typescript const game = defineGame({ setup: ({ playerIds }) => ({ players: Object.fromEntries( playerIds.map(id => [id, { x: 100, y: 100, health: 100 }]) ) }),

  actions: {
    move: (state, { playerId, dx, dy }) => {
      state.players[playerId].x += dx;
      state.players[playerId].y += dy;
    }
  }

That's it. No WebSockets, no serialization, no message handlers. martini-kit handles state sync, conflict resolution, connection handling, and message ordering automatically.

## How it works

Instead of thinking about messages, you think about state changes:

1. Define pure functions that transform state 2. One client is the "host" and runs the authoritative game loop 3. Host broadcasts state diffs (bandwidth optimized) 4. Clients patch their local state 5. Conflicts default to host-authoritative (customizable)

Those race conditions and ordering bugs are structurally impossible with this model.

## What's it good for

- Turn-based games, platformers, racing games, co-op games: works well - Fast-paced FPS with 60Hz tick rates: not ideal yet - Phaser adapter included, Unity/Godot adapters in progress - Works with P2P (WebRTC) or client-server (WebSocket) - Can integrate with Colyseus/Nakama/etc for matchmaking and auth

## Try it

[Interactive playground](https://martini.blueprintlab.io/preview) - test multiplayer instantly in your browser

Or install: ```bash npm install @martini-kit/core @martini-kit/phaser phaser ```

Links: - Website: https://martini.blueprintlab.io/ - Docs: https://martini.blueprintlab.io/docs - GitHub: https://github.com/BlueprintLabIO/martini - npm: https://www.npmjs.com/package/@martini-kit/core

Open to feedback and curious if anyone else has hit similar issues with multiplayer state management.

Comments URL: https://news.ycombinator.com/item?id=46044897

Points: 3

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=45564794

Points: 3

# Comments: 1

The prompts work by giving the AI specific context about each legend's communication style, technical philosophy, and personality traits. This pushes the AI beyond generic responses into more opinionated, stylized feedback that reflects their actual perspectives on code and architecture. Instead of "that's a great idea, but..." you get responses like "this is fundamentally broken because..." or "you're missing the point entirely..." - the kind of direct, opinionated feedback these legends are known for.

What it is: 1. Collection of prompts for 10 programming legends (not an AI tool itself) 2. Each prompt includes context about their communication style and technical views 3. Completely free and open source

Just copy-paste the prompts into any AI chat. The key is how the prompts frame the persona so there is enough context to make the AI adopt their actual communication patterns and technical stances.

Questions: 1. Have you tried persona-based prompting to get more opinionated responses? 2. Which programming legend would you want feedback from? 3. Do you think stylized prompts lead to better technical insights?

Would love to hear what you think!

Comments URL: https://news.ycombinator.com/item?id=45547570

Points: 3

# Comments: 2

Why you might care: - Fewer ambiguous instructions ("next Tuesday" -> 2025-09-23) - Works across timezones/locales - Choose formatting strategy: preserve, normalize, or hybrid

Quick example:

``` enhancePrompt("Schedule a demo next Tuesday and remind me tomorrow") → "Schedule a demo next Tuesday (2025-09-23) and remind me tomorrow (2025-09-16)" ```

Links: - Project: https://time-ai.blueprintlab.io - GitHub: https://github.com/BlueprintLabIO/time-ai - NPM: https://www.npmjs.com/package/@blueprintlabio/time-ai

Would love feedback on real-world prompts, tricky date phrases, and missing patterns.

Comments URL: https://news.ycombinator.com/item?id=45261780

Points: 1

# Comments: 0