Engenharia de Software com IA Aplicada: nine folders, one README

Nine module directories, one README, no root manifest

UNIPDS keeps the code and references for its postgraduate programme in software engineering with applied AI in this repository, and the description says so in Portuguese: codes and references used in the postgraduate course. The layout backs that claim up. Nine module directories run from `modulo01-fundamentos-de-ia-e-llms-para-programadores` to `modulo09-processamento-de-dados-e-fine-tuning-de-modelos`, covering LLM fundamentals, API integration, MCP, autonomous agents, AI tooling for UI and UX, AIOps, project management, system architecture, and data processing with fine-tuning. Four more directories, `embaixadores/`, `lives/`, `skills/` and `troubleshooting/`, stand beside them.

The gap sits at the root: the only files listed there are `.gitignore`, `.gitmodules`, `LICENSE.md` and `README.md`, so there is no package.json and no lockfile to install from, and that same LICENSE.md is a custom licence GitHub cannot classify, which means anyone reusing the code has to read the terms in the file rather than assume a standard header. Topic tags read `ai`, `javascript`, `langchain-js` and `typescript`, and GitHub reports TypeScript as the primary language, yet nothing here exports a package a project could depend on.

The lesson text is a link index, ordered like a reading list

Lesson 1.1 hands a newcomer the Teachable Machine site and the Kaggle Titanic competition together with its data page. Lesson 1.2 moves to an anatomy of a neural network article and a Google research post on the language of wearable sensors. Lesson 1.3 pairs CNN Explorer and the GAN lab with BERTViz, Netron and the TensorFlow dashboard.

One block shows what counts as a unit of study here. Under 1.4, on winning any game in the browser, the list points at two branches of one project, a dashboard and a web runtime:

- https://github.com/ErickWendel/DuckHunt-JS/tree/ml-self-play-template
- https://github.com/ErickWendel/DuckHunt-JS/tree/ml-self-play
- https://www.tensorflow.org/tensorboard
- https://ai.google.dev/edge/litert/web

Read as a sequence, that is a blank starting point, then a finished version of the same game, then the tools used to watch and serve the model. The prose never spells those steps out. The order of the list is the instruction, which is a fragile way to teach and a slow one to follow when a student wants to know which link is required and which is optional reading.

A lesson hands over its code as a relative path

In-repository examples are named by relative path rather than through a registry or an index file. Lesson 1.3.1 on recommendation systems points at one:

Projeto em [exemplo00](./modulo01-fundamentos-de-ia-e-llms-para-programadores/exemplo-00-z/)

The web AI lesson does the same twice:

Projeto em [exemplo-03-webai01](./modulo01-fundamentos-de-ia-e-llms-para-programadores/exemplo-03-webai01/)
Projeto em [exemplo-04-webai02-temperature-and-topK](./modulo01-fundamentos-de-ia-e-llms-para-programadores/exemplo-04-webai02-temperature-and-topK/)

Both sit under the first module directory, and the second folder name spells out the sampling controls the lesson teaches, temperature and topK. Naming a folder after the concept is a decent signal that the parameter names inside the code will match the lecture. Elsewhere the mapping is looser: the link text says `exemplo00` while the target directory is `exemplo-00-z`, and the recommendation lesson points at `exemplo-01-ecommerce-recomendations-z`, a name that describes the domain rather than the technique.

Lesson five lives inside modulo01, and 6.1 ends mid-word

Read the numbering closely and it stops agreeing with the directories. The text runs 1.1, 1.2, 1.3 and 1.4, then jumps straight to 5 - Módulo - Inteligência artificial na Web, with 5.1 on genetic algorithms, 5.2 on transformers, embeddings and attention, 5.3 on web AI, and 5.4 on multimodal AI inside browsers. There is no 2, no 3 and no 4 in the lesson text at all.

Those 5.x lessons attach their code to paths under modulo01-fundamentos-de-ia-e-llms-para-programadores, so the lesson counter and the directory counter are two separate series that agree only for the first module. Every project path visible in the README belongs to modulo01. After the web AI block, the text stops at 6.1 - Como escrever prompts que realmente geram boas respost, a heading cut off before its final letter and followed by no links whatsoever. Directories 02 through 09 exist on disk with no written lesson beside them.

Three links repeat inside a single curated list

The curation is manual and it shows. Block 1.1 lists the DataCamp machine and deep learning tutorial twice in a row. Block 1.2 repeats both the neural network anatomy article and the SensorLM research post. Section 5.1 lists the rednuht genetic cars page once beside the genetic algorithm demos and again at the bottom of the same list.

None of that misleads a reader, but it drains the signal from list position. When a block ends with a link you cannot read the last entry as the recommended capstone, and when a resource appears twice you cannot tell whether it was pinned on purpose or pasted by accident. The tic-tac-toe pile-up is a sharper example: five of the seventeen entries under 5.1 are reinforcement learning implementations of the same two-player game, and none of the five is marked as the one to read.

A submodule file with no lesson attached to it

A `.gitmodules` file sits at the root next to the README, which is how a git repository declares that some directories are submodules pointing at other repositories instead of ordinary folders. No line in the lesson text describes how to initialise them, and the 1.4 block still reaches outward to two named branches of `DuckHunt-JS` rather than using a local folder.

For a learner the consequence is that the code lives in different places depending on the lesson. Some hands over a relative path inside this repository. Others hand over a URL to somebody else's project, a Kaggle competition, a demo hosted on Google storage, or a Hugging Face Space. Upgrading is therefore nothing versioned: the last push was on 2026-09-16, there is no manifest to bump at the root, and any dependency drift is pushed into individual example folders that nobody watches as a set.

Every hands-on exercise asks for a browser

The example stack is the browser. Module one runs a webcam transfer learning demo from the TensorFlow.js examples, a cart-pole game from that same examples repository, and a browser game drawn with PixiJS. The 1.4 list even includes a caniuse query and an article on the using keyword for explicit resource management in JavaScript, which sets the prerequisite as working JavaScript rather than Python.

Section 5.3 reaches further out to models that live in the browser tab itself: the LiteRT web runtime documentation at `ai.google.dev/edge/litert/web`, Chrome's built-in AI API pages, the demo gallery at `chrome.dev/web-ai-demos`, and two Hugging Face Spaces under the `webml-community` organisation, `kokoro-web` and `deepseek-r1-webgpu`. The block closes with the WebMCP readme, a way of exposing tools to a model from inside the page.

None of that executes from this repository, and each dependency fails differently. A space whose name carries webgpu in it assumes hardware you may not have, a demo gallery served by a browser vendor tracks that vendor's own timetable, and hosted models under someone else's account can change or vanish. No browser version is pinned anywhere in the tree.

The standalone repositories it links teach differently

The `DuckHunt-JS` repository cited in 1.4 is the closest thing here to an alternative, and the difference is structural rather than topical. It publishes two branches, `ml-self-play-template` and `ml-self-play`, so a learner either fills in an empty starting point or diffs their own result against a finished one, inside a project that carries its own setup notes and its own history.

This repository does the opposite. It owns the ordering, the vocabulary and the Portuguese framing, keeps nine module directories in one tree, and lets a lecture point at whatever external artefact fits the week, including a Kaggle dataset or a Medium post. The cost is that no module text states a version for any of those artefacts, and the written lessons stop inside the first module while the directory list runs to nine.

Pick the standalone repository when you want one topic end to end with instructions that stay next to the code. Pick this one when you want the sequence and be willing to source the write-ups for the remaining modules elsewhere.

Editorial conclusion

Adopt this repository as a syllabus, not as a dependency: it can order your first weeks of applied AI work, and nothing in it can be installed, versioned or pinned for you. The ordering is the part that ships, while the example code arrives as links you have to go and fetch. Leave it alone if you want a production building block or a reproducible environment. Before spending an afternoon on it, open the module directory you actually need, confirm the example folders arrive populated after a clone, and read the custom terms file at the root before reusing any code.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. unipds-engenharia-de-ia-aplicada/engenharia-de-software-com-ia-aplicada on GitHub