ToCode

create a python program that counts how many prime numbers are there between 1 and 1000000

what if memory is a constraints?

what if we were counting until 100000000000 ?

Expand the dillema and better explain each side. Provide examples to possible problems or advantages of each approach. You don't have to recommend an approach let's just contemplate the conflict

        "- A 'Top Stories' section: the 5-8 most significant stories across all "
        "sources, each with a one-sentence summary based on its title, a link, "
        "and its source.\n"
        "- A short 'Also Worth a Look' bullet list of 5-10 more headlines with "
        "links.\n"
        "Merge duplicate stories that appear on multiple sources and mention "
        "each source's engagement (points/score/comments) where notable."
    ),
    model=OpenAIChatCompletionsModel(model=MODEL_NAME, openai_client=gemini_client),
    tools=[fetch_hacker_news, fetch_reddit_programming, fetch_lobsters, fetch_devto],
)


async def main() -> None:
    today = datetime.date.today().strftime("%B %d, %Y")
    result = await Runner.run(
        news_agent, f"Generate the tech news digest for today, {today}."
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

OpenAI-compatible chat completions endpoint.
"""

import asyncio
import datetime
import os

import httpx
from agents import (
    Agent,
    OpenAIChatCompletionsModel,
    Runner,
    function_tool,
    set_tracing_disabled,
)
from dotenv import load_dotenv
from openai import AsyncOpenAI

load_dotenv()

GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
MODEL_NAME = "gemini-2.5-flash"

gemini_client = AsyncOpenAI(
    base_url=GEMINI_BASE_URL,
    api_key=os.environ["GEMINI_API_KEY"],
)

# Tracing exports to the OpenAI platform, which we have no key for.
set_tracing_disabled(True)

HTTP_HEADERS = {"User-Agent": "news-digest-agent/0.1 (daily tech digest demo)"}


async def _get_json(url: str, params: dict | None = None):
    async with httpx.AsyncClient(
        headers=HTTP_HEADERS, timeout=30, follow_redirects=True
    ) as client:
        response = await client.get(url, params=params)
        response.raise_for_status()
        return response.json()


@function_tool
async def fetch_hacker_news(limit: int = 15) -> list[dict]:
    """Fetch the current Hacker News front page stories.

    Args:
        limit: Maximum number of stories to return.
    """
    data = await _get_json(
        "https://hn.algolia.com/api/v1/search",
        params={"tags": "front_page", "hitsPerPage": limit},
    )
    return [
        {
            "title": hit["title"],
            "url": hit.get("url"),
            "points": hit.get("points"),
            "comments": hit.get("num_comments"),
            "discussion": f"https://news.ycombinator.com/item?id={hit['objectID']}",
        }
        for hit in data["hits"]
    ]


@function_tool
async def fetch_reddit_programming(limit: int = 15) -> list[dict]:
    """Fetch the hottest posts from reddit.com/r/programming.

    Args:
        limit: Maximum number of posts to return.
    """
    data = await _get_json(
        "https://www.reddit.com/r/programming/hot.json", params={"limit": limit}
    )
    return [
        {
            "title": post["data"]["title"],
            "url": post["data"]["url"],
            "score": post["data"]["score"],
            "comments": post["data"]["num_comments"],
            "discussion": f"https://www.reddit.com{post['data']['permalink']}",
        }
        for post in data["data"]["children"]
        if not post["data"].get("stickied")
    ]


@function_tool
async def fetch_lobsters(limit: int = 15) -> list[dict]:
    """Fetch the hottest stories from lobste.rs.

    Args:
        limit: Maximum number of stories to return.
    """
    data = await _get_json("https://lobste.rs/hottest.json")
    return [
        {
            "title": story["title"],
            "url": story["url"] or story["comments_url"],
            "score": story["score"],
            "comments": story["comment_count"],
            "tags": story["tags"],
            "discussion": story["comments_url"],
        }
        for story in data[:limit]
    ]


@function_tool
async def fetch_devto(limit: int = 15) -> list[dict]:
    """Fetch today's top articles from dev.to.

    Args:
        limit: Maximum number of articles to return.
    """
    data = await _get_json(
        "https://dev.to/api/articles", params={"top": 1, "per_page": limit}
    )
    return [
        {
            "title": article["title"],
            "url": article["url"],
            "reactions": article["positive_reactions_count"],
            "comments": article["comments_count"],
            "tags": article.get("tag_list", []),
        }
        for article in data
    ]


news_agent = Agent(
    name="News Searcher",
    instructions=(
        "You are a tech news editor producing a daily digest.\n"
        "Use ALL of your tools to gather today's top stories from Hacker News, "
        "r/programming, Lobsters, and Dev.to.\n"
        "Then write a digest in markdown with:\n"
        "- A title with today's date and a 2-3 sentence overview of the day's "
        "main themes.\n"

Bootstrap the agent according to Claude.md
  in single file main.py
  Use Gemini and the OpenAI compatible chat endpoint
  Print out the daily digest to stdout
 
  Tech sites should include https://www.reddit.com/r/programming/, hackernews and whatever else you can think of

"""News Searcher: searches tech news sites and prints a daily digest to stdout.

Built with the OpenAI Agents SDK, running Gemini through its

When people praise AI coding on HN, the praise is almost always about capability, speed, and unblocking — "I shipped an iOS app in two weeks," "10–20x more features," "it found the bug in five minutes." The code-as-craft dimension, when it shows up at all, tends to show up as criticism: the recurring argument that AI code is "always good enough and never great" because great code requires taste and judgment about what's appropriate, what's overkill, what's elegant for this specific codebase.