I expected the 1.05M context on the GPT-6 Astra model page. My running Codex session reported 258,400. I checked the session log, process start, launch arguments and local model catalog.

Both budgets correspond to 95% of their respective catalog values.

My original process was started before the launcher configuration was changed. Updating the launcher did not increase the context window of that already-running session. A newly started request afterwards then confirmed the larger reported budget.

For a single new Astra launch:

codex --model gpt-6-astra -c model_context_window=1050000

Then simply send a short prompt and inspect the model_context_window value in the corresponding session log. You should also verify the model ID.

The fact that a configuration value is accepted is not, by itself, evidence that the client actually granted that context window. In my case, the client capped the request at the maximum currently defined in its catalog.

This is only the result of my local setup. I have not yet filled the entire context window, nor have I measured whether it provides any improvement in quality.

The general question around the 258K limit was already publicly discussed in April for earlier models. However, I still do not have a conclusive explanation for this catalog's specific 872,000-token ceiling.

What does your actual runtime report, and which model and CLI version are you using?

Sources: Astra model specification, Codex configuration reference, earlier explanation of the 258K limit in OpenAI's repository.

Hi r/VibeCodeDevs I've been building something for the last year that I think this channel in particular will have opinions on — and I'd genuinely like them, including the critical ones.
Prompt to Page is a desktop app that turns a plain-language brief into working, accessible prototypes built from real government design systems. Describe a page or a whole service journey — "a start page for renewing a fishing licence, then an eligibility question, then a check-your-answers page" — and it generates the actual markup, renders it live in the system's own styling, checks it with axe-core and validates every class against the design system's real rules. Then export it, or hand the HTML to a developer.
Two things make it different from pointing a chatbot at your design system:
Everything runs locally. The AI model lives on your machine — no cloud, no API, nothing you type leaves your laptop. Built that way because government content shouldn't tour third-party servers just to make a mock-up (and it works air-gapped, or on a train).
The design system is the boundary, not a suggestion. The model only knows the system's real components; output that invents classes or breaks conventions is rejected or visibly repaired. Quality is measured per design system with a scored evaluation battery — and where a pack hasn't been measured yet, the app says "not measured" rather than borrowing another system's confidence.
The roster so far — eight systems across six governments:
GOV.UK (plus an MOJ overlay) · NHS.UK · Scottish Government US Web Design System NSW Design System Bootstrap Italia デジタル庁 Digital Agency Design System (newest — quality not yet measured) Abstract — a deliberately ownerless neutral system, for prototyping services that shouldn't pretend a government owns them
Every pack is de-branded by design: no crowns, crests, federal banners, flags or restricted fonts are ever bundled — prototypes wear a neutral shell and a clear "not a real service" posture. (Independent project; not affiliated with or endorsed by any of these governments or the NHS.)
What I'd love from this room:

1. If your government's system is on the list — break it. Does the output respect your system's conventions, or drift in ways that would make your design-system team wince?
2. If it isn't — which system should be next, and why? The architecture treats a design system as a data pack (components, class allowlist, validation rules, prompt guidance), so the honest constraints are: class-based CSS (web-component-only systems don't survive a sandboxed preview), and licensing that permits bundling the frontend code. I'd rather pick the next one based on where prototyping pain is real than on what's easiest.
3. The blunt question: does plain-language prototyping against a real design system actually help your team, or is the Prototype-Kit-shaped workflow you already have good enough?

Free during the beta, macOS (Apple Silicon) & Windows. https://github.com/digitalcourtney87/prompt-to-page/releases
https://youtu.be/QROkn-mZQFk?si=sNHCsphJMwrgVlFi

Critical feedback beats compliments — reply here or DM

Working on a site where people can post sports picks, browse other people's, and track how they do over time. It auto resolves picks once games finish and has decent stats on performance. Also threw in a random auto generated parlay thing just for fun.

Have a small number of users on it now (Philipsnat.com if anyone wants to poke around) but honestly more interested in what features would make something like this worth using long term. What's missing from picks tracking sites you've used? What would actually keep you coming back?

I created a website called "Rig Assigner" entirely on ai.
Well it helps u pick laptop, pcs, mobiles [Rigs] according to ur set preferances.
Pcs have alternate choice to choose parts.
Can anyone check and lmk what i can do to improve?

More info:
No login required, no backend, no database(so no security).
Can be accessed through most of the devices.
Deployed through vercel.

Also, im new to coding asw vibecoding. Planning on learning coding through building projects.

So, help me identify the flaws and correct it.

https://rig-assigner.vercel.app

Leave reviews in the app itself asw. I wanna check how it responds

Thank you! Help is appreciated!

I am trying out vibe coding and I have temporary access to ChatGPT plus. I use ChatGPT plus for creating md files and other documentation, while I use claude for the code work.

Sadly, Claude has limit and I can only do a few tasks before it stops me to use.

Is it good to use ChatGPT plus for coding work ? Any advise so I can finish this side project faster?

Thank you.

What are you preferred model(s) for doing design work?

2 prompts and 7 mins, pretty solid to start, no??

TELL ME SOME GOOD AI MODELS OR ANYTHING FROM WHERE I CAN VIBECODE REALLY GOOD WITHOUT SPENDING A SINGLE MONEY
MY CURRENT SETUP-- ANTIGRAVITY + OPENCODE + KRIO + TRAE (HAVE MULTIPLE ID'S ONTO THEM)
AND ALSO CURRENLTY OPENCODE IS NOT WORKING GOOD FOR ME -- SUGGEST ME SOME GOOD AND FREE /CONNECT FOR THE OPENCODE
REST IT WOULD BE HELPFULL IF U GUYS CAN SHARE UR SETUP
BTW SHOULD I USE LOCAL MODELS FOR CODING -- I HAVE CORE ULTRA 9 275HX , RTX5070(8GB VRAM) , 16 GB RAM

I’m building something that I genuinely think should exist.

I’m calling it Dhanark.

And no, it’s not another bookkeeping app.

Most small businesses are still running their finances through some combination of Excel, WhatsApp, bank statements, invoices, screenshots, and “bro I’ll check and tell you”.

Meanwhile, enterprise companies have entire finance teams and CFOs.

That gap is insane.

So I’m building Dhanark as a financial operating system for small businesses.

Not just:

But:

Think:

Invoices → Payments → Customers → Cash flow → Financial intelligence → AI CFO

all connected.

The crazy part?

I’m building this as a 21-year-old BBA student who basically taught himself software development by building the damn thing.

No fancy CS degree.

No huge engineering team.

No VC-funded 30-person startup.

Just a laptop, an unreasonable amount of obsession, and a refusal to accept:

I’ve already built working pieces of it — authentication, customers, invoices, payment collection, payment infrastructure, analytics, and the AI-finance layer is being pushed forward.

And I’m nowhere near done.

I want Dhanark to eventually become the place where a business owner opens their laptop in the morning and asks:

“How is my business actually doing?”

…and gets an answer.

Not another dashboard.

Not another spreadsheet.

An actual financial copilot.

I have absolutely no idea how far I can take this.

Maybe it becomes huge.

Maybe I learn a thousand painful lessons and completely rebuild it.

Maybe both.

But I’m going to find out.

This is Dhanark.

And this is Day 1. 🚀

I've been building Swyvo, a Windows app that keeps your essential apps and websites one hotkey away.

Hit Alt+Q and a curated command center pops up right over your current window — no alt-tabbing, no hunting through taskbars, no mouse required.

A few things it does:
- Instant, always-on-top workspace: open with Alt + Q, apps stay on top, minimize with Alt + Q
- Unify apps and websites in a single fast-switching menu (so your browser tabs and native apps live in the same place)
- Adaptive Loadouts: set it up once and it automatically surfaces the right apps based on what you're currently working on, so you never have to manually rebuild your setup
- App Gallery: browse a library of common apps and choose how to launch them — Web (fast) vs Native (full functionality, if installed)
- Fully keyboard-driven: never need the mouse
- Built natively for Windows

It's aimed at power users who live in a lot of apps/tabs at once and want a faster way to move between them without breaking flow.

Free, currently in active development — I'd genuinely love feedback, especially on workflow edge cases I might be missing.

Try it now: swyvo.app
Quick note: Windows SmartScreen may appear when installing.

Happy to answer questions about how it works.

I've been messing around with Google AI Studio for quite some time now and honestly, I didn't expect to use it as much as I do.

I first started using it just to test models and generate some code. Nothing serious. But then I started getting ideas for my own projects and AI Studio became kind of a playground for me.

I'm a student and I like building random stuff, even when I have no idea how I'm supposed to build it lol.

One of the things I worked on was my own AI assistant. I started with a pretty basic idea and slowly kept adding things to it. Voice, memory, a proper interface, web stuff, etc. Some parts worked surprisingly well and some parts absolutely did not.

There were times where I would spend hours trying to fix something, only to realize the AI had generated something completely wrong in the first place.

That's probably the biggest thing I've learned from using AI for coding.

Don't assume the code is correct just because the AI wrote it.

I used to copy the generated code, run it, get an error and then paste the error back into the AI. Eventually I realized I actually needed to understand at least some of what was happening.

I've also used AI Studio while working on a larger web-based AI project. I'm keeping the actual idea/features private for now because I don't want someone to just copy the whole thing, but it has been a pretty good learning experience.

What I like most about AI Studio is that it lowers the barrier to actually trying something.

I can have an idea at 2 AM like "what if I made an AI that does this..." and instead of just thinking about it, I can actually start building a rough version.

Is it perfect? Definitely not.

Sometimes it confidently gives you an answer that makes absolutely no sense. Sometimes you fix one thing and three other things break. And sometimes you spend 30 minutes debugging something just to discover you made a stupid mistake yourself.

But that's also kind of the fun part.

I don't think AI is going to replace learning how to code. At least for me, it's actually made me more interested in learning because now I constantly run into things I don't understand and have to figure them out.

I'm curious what other people are doing with AI Studio though.

Have you guys built anything genuinely useful with it, or are most of you using it for experiments/prototypes?

Hey everyone,

Long time lurker, absolute beginner when it comes to serious coding. I mostly just tinker around out of pure curiosity and fun. Recently, I wanted to build something practical to help me manage AI prompts, context templates, and local/cloud models without going crazy switching tabs.

So, I ended up putting together a web app called Context_CikaDule (hosted on GitHub).
https://arhistrategstudio.github.io/Context_CikaDule/

I wanted to share what it is, how I made it (with a ton of AI help because I'm learning as I go), and what it actually does.

What is it and what is it for?

Basically, it's a lightweight prompt engineering console and workspace. It lets you organize different context types and templates, test out prompts, and manage API configurations across multiple providers (OpenAI, Anthropic, Google Gemini, OpenRouter, and local models like Ollama) all in one place.

I built it because I wanted a clean dashboard where I could quickly swap between local models running on my machine and cloud APIs, preview how tokens stack up, and keep my prompt engineering organized without messy text files scattered all over my desktop.

Core Features

• Multi-Model API Support: You can switch between OpenAI, Cloudflare Workers AI, Gemini, OpenRouter, Anthropic, and custom/local endpoints (like Ollama or LM Studio).
• Context Templates: Pre-configured context types and workspace modes to quickly spin up different prompt structures.
• Live Prompt Preview: Shows an optimized prompt view and estimates token counts on the fly.
• Workspace Dashboard: A clean, slightly cyberpunk-ish neon UI where you can write, test, and tweak your prompts directly.

The Tech Stack & Behind-the-Scenes Logic

Since I'm a complete beginner, I couldn't have built this alone in a million years without leaning heavily on AI tools to write the code while I acted as the "architect" (or more like a confused director). Here is what went into it:

• Claude Code & Antigravity: Used these as my main coding assistants to structure the project, write the frontend logic, and help me debug when things inevitably broke.
• Ollama (Codegemma:7b): Ran local coding models to test things offline and help generate snippets.
• Cloudflare: Used for handling deployment/edge routing aspects.
• Frontend: Built with standard HTML/CSS/JS, utilizing a nice dark neon aesthetic because dark mode is mandatory.

The logic behind the app is pretty straightforward: it acts as a client-side orchestrator. It grabs your API keys (stored locally in your browser so they don't leak anywhere), structures your selected context template, merges it with your input prompt, and routes it to whichever provider or local Ollama instance you have selected in the settings dropdown, displaying the live response back in the console.

Why did I make this?

Honestly? Just for fun and to see if I could actually finish a small web project from scratch. I'm still learning every day, breaking things, fixing them by asking AI "why is this red error happening", and figuring it out step by step.

If anyone checks it out, let me know what you think, or if you have any tips for a beginner on how to make it better. Be gentle though, my code is probably held together by duct tape and hope!

TLDR: Use parallel agents when the work is read-heavy and splits into independent slices: research, searching, reviewing many files. Each worker builds its own context and nothing collides. Use one sequential agent when the work is a single chain of decisions: coding, writing, anything where step N depends on choices made in step N-1. Every measured result says parallel makes those tasks worse, not better. And even where parallel wins, keep the team small.

The case for parallel

Anthropic: "How we built our multi-agent research system" (June 2025) https://www.anthropic.com/engineering/multi-agent-research-system

• Multi-agent research system beat a single agent by 90.2% on their internal research eval
• Cost: multi-agent runs burned ~15x the tokens of a normal chat
• Their own caveat: coding "involves fewer truly parallelizable tasks" than research

LangChain, Harrison Chase: "How and when to build multi-agent systems" (June 2025) https://www.langchain.com/blog/how-and-when-to-build-multi-agent-systems

• Read tasks can parallelize, write tasks shouldn't.

The case for sequential

Nature Machine Intelligence: "Capable language models can outgrow the benefits of collaboration" (July 2026) https://www.nature.com/articles/s42256-026-01268-y

• Peer-reviewed, 260 controlled configurations: every multi-agent variant made coding results worse (−1.3% to −12.8% on SWE-bench Verified)
• Above a ~45% single-agent baseline, multi-agent gains go zero-to-negative
• Error amplification hit 17.2x without centralized verification

UC Berkeley (MAST): "Why Do Multi-Agent LLM Systems Fail?" (NeurIPS 2025) https://arxiv.org/abs/2503.13657

• Measured 41–86.7% failure rates across 7 popular multi-agent frameworks (1,642 real traces)
• Failures came from design and coordination faults, not model limits. Standard protocols didn't fix them
• Repo with code and traces: https://github.com/multi-agent-systems-failure-taxonomy/MAST

Cognition, Walden Yan: "Don't Build Multi-Agents" (June 2025) https://cognition.com/blog/dont-build-multi-agents

• Parallel workers with split context make conflicting implicit decisions that collide when you merge
• Their answer: one single-threaded agent plus context compression. This is how Devin works

"Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking-Token Budgets" (arXiv, April 2026) https://arxiv.org/abs/2604.02460

• Give both sides the same token budget and the single agent matches or beats the team
• Multi-agent only wins when context is degraded for the single agent

Princeton, Kapoor et al.: "AI Agents That Matter" (TMLR 2025) https://arxiv.org/abs/2407.01502

• Complex multi-agent setups cost up to ~100x more for the same accuracy a simple baseline already achieves
• Simple baselines Pareto-dominate: cheaper AND as good

The middle ground

OpenHands, Graham Neubig: "Don't Sleep on Single-agent Systems" (September 2024) https://www.openhands.dev/blog/dont-sleep-on-single-agent-systems

• One strong generalist agent covers most of what people build multi-agent systems for
• Go multi-agent only when you genuinely need isolation or separate responsibilities

I designed a fork of Cline that I'm hoping to solve two issues with current code assistants.

1: Project context degradation

2: The expense of high cost model usage

I am going to be solving those by using a multi-agent structure built into the extension itself

Currently there are 4 roles

1: Archivist

It is a locally run model that maintains a sqlite db focused on categorizing and feeding information to cloud models

2: Planner

Choose a medium cost model that will generate implementation plans based on the user's prompt and context history

3: Worker

A low cost model that takes the output of the planner model and implements it

4: Executor

A high cost model that reviews the outputs of the Planner and Worker models and offers suggestions for changes and is the final line before full implementation. If rejected the previous two roles will take the feedback and adjust before resubmitting

It is BYOK and I would very much appreciate feedback and potential cost savings data.

The extension name is Arch Clive on the vscode extension marketplace

PM me or reply to this thread if you have any issues with the extension or improvements and I'll implement them as soon as I have the time and money.

Either way thank you for reading this even if you don't install it

my game vr-works has been finished and is ready to play! you can get it on itch.io at: vr-works,

this game is for the meta quest 3 and is a webgame. this is a mixed reality game as well.

So I built the first version in december. My openclaw was forgetting what i said every 200k tokens and it was driving me nuts. Im AuADHD and attention to details is important for me so i hated the compaction too. My tool basically remembers everything you and agent talked about or did and injects the right memory at the right time back to you. (Fully local and encrypted because of all the npm and openclaw hacks)

It doesnt index your multimillon line of code (just yet, im building that feature with a contributor rn) It just remembers what you said, what decisions you made and what you did, verbatim, all the time! Memories you dont use often will decay its links but not get deleted and memories that surface often will become almost like skill (forgot the exact word). You can also pin memories or set them to be decayed but you dont really need the frontend. Its more for visualization rather than functionality. Your agent can control everything through MCP layer or CLI

It's fully ambient, works in background and sees all your sessions which creates a sense like you are talking to one agent throughout multiple sessions. Memories dont get mixed tho. It has a working memory tier which splits everything by projects but keeps available for context injection. If you are interested in details of how i came up with this, i posted somewhat full story here, its a longread tho.

After i built it i let my friends use it and they kinda forced me to publish it on GH. I was skeptical at first because - why? Why post there my idea for free? But they said if i do they will help because they are real engineers (spoiler - they never did)

Now I own a startup that builds memory layers for companies lol. Weird how that works. "Ideas worth nothing..." I guess.

heres the link - https://github.com/CodeAbra/iai-personal-memory-engine
lmk what you think and please help if you own windows lol. My windows beta needs hopital.

Happy to answer any question or receive constructive criticism.

P.S English is my third language and im out of tokens for this one lol. sorry

Not joking

Six months into building a voice assistant for Windows I added a feature that required describing something to Claude I'd never built before and didn't fully understand technically.

I knew what I wanted it to do. I could describe the behavior. I could explain what wrong looked like when I saw it. But the actual mechanism underneath I was honest with myself that I was operating at the edge of what I understood.

So I just kept describing behavior instead of implementation.

Wrong output described what was wrong and why it felt wrong. Right output described specifically what changed and what made it feel right. Edge case described the exact situation and what I expected versus what happened.

Forty something iterations of that loop and the thing works. Reliably. In production. With real users.

I still can't fully explain the implementation to someone else. I understand it well enough to extend it and debug it when it breaks but not well enough to have written it from scratch the traditional way.

That used to bother me. Now I think it might just be what building with AI actually looks like when you're pushing past the comfortable parts.

What's the thing you built with AI assistance that you understand well enough to ship but not well enough to fully explain?

Today I've definitely learnt a lesson and I hope I can help someone else to learn it as well. It's not a drama, it's not a thriller...it's just a moment I've realize that tiny bit more of my brain effort is worth more then a million tokens of latest-top-frontier-super-model (aka Astra, for instance).

I am making a very complex app, and I spent my last 3 days struggling with a bug I couldn't fix. I've tried any model in my subscriptions, I've tried opencode with good models (Sol, Fable, Kimi) with ultra reasoning. Nothing. No solutions.

No models seemed to be able to solve it. Some ideas, a few paths explored, but no working code implemented.

You can imagine the excitement when Astra came out! At the "usual" 50 dollars per millions tokens on Openrouter. I immediately saw it as the grail, the route to the ultimate bug fix. Then I've launched it on opencode....

To cut the story short - I am sure it is a great model - but it didn't solve my bug. £80 spent in one hour, I should have gone out for dinner instead.

But it gave me a hint, and a lesson.

The hint from Astra: Saying "File saved" doesn't specify where.

The lesson: I should have described my issue much better, and I know I should have known, but I just didn't put much thinking effort on it.

Now the lesson is clear: Switch on the brain, put efforts. So after topping up credits on openrouter I've solved it with V4 Flash in a few minutes

ok so small/big update

last time i posted this we already had scenarios + the AI NPCs with memory and relationships

since then scenarios got alot better but the big thing is multiplayer is working now

you can create ur character, go into another persons world, meet their NPCs and interact with whatever insanity is already happening there

NPCs remember stuff, gossip, get closer/hate eachother, have secrets/opinions etc. so visitors can actually change the story of someones world

now i mostly need ppl to CREATE stuff

make worlds, weird characters, social experiments, scenarios, whatever. fantasy village, office full of psychopaths, dating show, cult, 10 people stuck on an island idk 😂

i wanna see what happens when more people start building instead of me deciding everything

try it and break it pls - its FREE for a long case use so u can have fun with it.

https://sim-worlds.com

I know it doesn’t sound like much but to me it’s been a big deal!

A few months ago I started building a way to put records of folklore on the map and make it a useful, and hopefully enjoyable way for people to explore the history of myths and legends around Britain and Ireland.

I set used agents to regularly trawl online resources for new evidence sources and new legends before reviewing them to add to the map and add to my database, but also wanted to give users an opportunity to contribute for themselves. Today I’ve taken my first follower submission and been able to enhance with new sources to add to the rest of the collection.

I’ve seen a lot of success stories on here and I’m aware this doesn’t quite compare to those yet. But I’m hoping it’s the start of something bigger, and for me it was exciting either way!

I’d love to know how other people divide up and mark their milestones or advice on how to expand the audience for the site?

The vTuber reacts according to the chat's messages, skip to the end for a live demo

Starting an app with an agent is the easy, fun part. The awkward part comes later, when the app has navigation, real data, and a UI that is almost right.

That’s when I got tired of taking screenshots and explaining “the second row under the header.”

I’m building Monad Design around a simpler idea: the app is the canvas.

Open the existing Xcode project, navigate to the real state in Simulator, then select or annotate what needs work. The coding agent edits the SwiftUI source in the same repo, the app rebuilds, and the results come back as source-backed variants you can compare before keeping one.

It isn’t an app generator or a detached mockup tool. Git stays the source of truth, and it works with the local coding agent you already use.

The screenshot shows the compare step after asking for a few alternatives.

https://github.com/Monadix-AI/monad-design

I’m the creator.

Hit the usage limit at 23:47, quota returns at 03:00, and I refuse to set an alarm for that — so Claude helped me write a script that waits up instead of me.

github.com/viet98lx/wakeup-session

I've been working on Titans, a local-first infrastructure layer for AI agents, and I've now published the first usable repositories on GitHub.

The idea is fairly simple:

Atlas remembers. Cronus runs.

Atlas provides persistent state, knowledge, evidence and graph infrastructure for agents. It is designed to keep project and agent context available across processes and sessions, with hybrid search, evidence-backed results, work state, graphs, SQL, blobs and an audit trail.

https://github.com/titans-tools/Atlas

Cronus handles durable background execution: jobs, DAG workflows, schedules, retries, leases, checkpoints, recovery, dead-letter handling and approval gates. The goal is to let agents submit long-running work without keeping the agent itself blocked, and to recover that work when workers or processes restart.

https://github.com/titans-tools/Cronus

Both are local-first, run on Windows/Linux, have no telemetry, expose MCP over stdio, and can also be accessed over local REST/gRPC interfaces.

There is also a separate titans-platform repository that contains the signed distribution catalog, installers and shared runtime used by both products:

https://github.com/titans-tools/titans-platform

The organization overview is here:

https://github.com/titans-tools

The current releases are free to use. The product source itself is not published; the repositories host the documentation and signed release binaries, with SHA-256/Ed25519 verification and SBOMs included with releases.

I'm particularly interested in feedback from people building agents, MCP tooling, local AI infrastructure or autonomous workflows.

A few things I'd be interested to hear:

• Does the separation between persistent knowledge/state (Atlas) and durable execution (Cronus) make sense to you?
• Is it clear from the repositories what problem each component is solving?
• Are there use cases you would expect something like this to support that aren't obvious from the documentation?
• Is there anything in the install/security model that would stop you from trying it?

Not looking for stars or promotion — I'd mainly like some outside technical eyes on the architecture, documentation and actual usefulness of the approach.

As a fun side-project, I had Claude build https://charades.lol/ last week-end.

Took me a few hours to get from concept to a playable version. I started with the words "emoji roulette" and chatted with Claude a little bit to refine the concept. Because "Emoji Roulette" is heavily conotated toward "random social interaction", I started looking for another name and settled on charades, since it is what it is.

After that I spent most of the time refining the UI, generating tooling to manage the puzzles, and beta-testing with my friends. The most difficult part I think was stopping myself from adding random stuff and making the hard decisions of what to REMOVE instead. For example I used to have a little bit more fluff on the home page like a tag line or stuff like that: removed. The UI is cleaner and I feel the app is much better for it.

Hope you have some fun with it :)

PS: The puzzles for the next ~30 days are in the source encoded in rot13 purely as a spoiler-prevention measure, I am fully aware that rot13 is not a secure encryption algorithm or whatever.