OpenAI is rolling out new visual ad formats in ChatGPT alongside expanded measurement, attribution, and brand suitability tools for advertisers. The move signals how advertising may be woven more…

#ChatGPT #AD #OpenAI #AIDevTools
https://openai.com/index/new-chatgpt-ads-format-and-measurement

OpenAI is expanding the Lenfest AI Collaborative and Fellowship Program with $5 million in funding and up to $5 million in software credits and engineering support.

#OpenAI #AIDevTools #DeveloperCredits
https://openai.com/index/lenfest-ai-collaborative-expansion

7/ The module assessment puts these concepts into practice. It involves extending an order tracking app by building a telemetry pipeline, configuring Grafana alerts, and wiring a webhook to an AI responder that automatically investigates and fixes a date calculation bug. #aidevtools

6/ When your AI on-call engineer investigates an alert, it needs clear boundaries. Instruct it to reproduce the bug, write a small fix, and run tests. But if it determines the alert is a false positive, it should just explain why and leave the code alone. #aidevtools

5/ An AI agent can act as your first on-call responder. By setting up a worker to poll your observability API, you can wake up a headless coding agent when an alert fires, pass it the details, and ask it to investigate the root cause. #aidevtools

4/ A useful alert carries enough context to act on: threshold, duration, service, environment, deployed version, and a dashboard link. Without that, an alert just adds noise instead of information. #aidevtools

3/ Building the image during the deploy step means a promoted release isn't guaranteed to match what was tested in dev. Splitting build and deploy into separate stages, with a container registry between them, closes that gap. #aidevtools

2/ Metrics give concrete numbers, logs give detail on individual events, traces show the path a single request takes through the system. CPU and memory alone don't count as observability, they don't explain why something is failing. #aidevtools

Module 4 sets up a dedicated development environment for automatic deployments, while requiring a manual promotion trigger for production. It's an essential guardrail, ensuring you don't push buggy code straight to real users the moment a commit is made. #aidevtools

7/ CI/CD is not just a faster path to production. By requiring unit, integration, and end-to-end checks before deployment, then verifying the health endpoint afterwards, it makes release confidence a property of the workflow. #aidevtools

6/ Docker Compose makes the application’s real dependency boundary testable: the app runs with Postgres, waits for database readiness, and supports integration and browser-based end-to-end checks in one repeatable environment. #aidevtools

5/ Moving deployment from a manually supervised admin account to GitHub Actions with a restricted AWS OIDC role is more than automation: it turns production access into a controlled, test-gated, and verifiable part of delivery. #aidevtools

4/ Agent Relay + PostgreSQL deployed to kind with Services, persistent storage, Secrets and health probes. Readiness was checked against the live database; port-forwarding confirmed the dashboard end to end. Running isn’t enough. #Kubernetes #aidevtools

3/ A Docker image can build and still be wrong at runtime. My container tried to re-sync dev dependencies on startup because `uv run` lacked `--no-sync`. A smoke test caught it; the rebuilt image started cleanly with no runtime downloads. #aidevtools

2/ For Module 3 of AI Dev Tools Zoomcamp, I’m deploying Agent Relay, a small messaging system for software agents. Rather than direct messaging or a broker, agents claim DB-backed tasks through HTTP. The dashboard makes the lifecycle visible. #aidevtools

Module 3 uses a separate Vite dev service for tight feedback, then builds static assets to keep production down to one simple container. It's a great approach, though heavy scaling often requires splitting services for independent deployment and fault isolation. #aidevtools

7/ Connected frontend to FastAPI (in‑memory). Added CORS, implemented ApiWaitlistService with fetch, kept mock for tests. Verified every flow with curl (guest join, staff login, queue ops, table CRUD, large‑party) before SQLAlchemy. Integration first, persistence next. #aidevtools

6/ The backend was generated against openapi.yaml: routers, schemas, services, in-memory repository, seeded demo data. A small script compares app.openapi() with the spec to catch drift early. 52 tests cover auth, guest flows, staff operations, and tables. #aidevtools

5/ Table management started as “show tables” in the UI. Extending it to CRUD + availability states (available / occupied / needs_tidying) required changes in: service interface, mock, OpenAPI, and later backend. Small feature, but a clean end-to-end slice. #aidevtools

4/ The product spec described “what Table Ready should do”. The real API contract came from the frontend’s WaitlistService interface: one method per operation, with explicit request/response types. That interface, not the spec text, drove the OpenAPI design. #aidevtools