Microcontroller Dev Boards: What features do you like to have (or to add?)

i don't really have requests in stuff that should be on the board, I prefer to have zero clutter or parts that I don't really use in the project present to avoid conflicts and confusion on my part. also I don´t like any customization in routing that require Arduino cores, DTOs or any other compability layer , not even a renumbering of the pins. Everything should work exactly as if I put the bare chip I build upon on a board, NO deviationsm no porting.
My biggest request is to have Flawless software support OOTB, no special linux derivates that never get updated or proprietary SDKs.
a simple way without any additonal hardware to flash code / boot (native usb for example is great)
and absolutelly Open source construction, no proprietary software needed and only Bog standard mainline Linux support on day one. that would be my biggest request.

I think of it as 4 levels of dev card, each is useful:

1. The starting point as Jan Cumps  would say is to breakout every pin of the MCU onto a header and provide enough infrastructure to program and rum.
2. The next step up for me would be to incorporate standard connectors for standard interfaces. Like USB, UART, SPI + power, I2C + power, Analog + power, digital + power, servo, etc.
3. The next step up for me would be to incorporate standard connectors for standard peripherals and communication functions. Like a display or HDMI, keypad, Bluetooth, WiFi, audio, video, MIPI, SD, etc.
4. Then finally more complete but constrained systems that include on-board peripherals like displays, sensors, speakers, keypads, cameras, microphones, etc.

The difference between level 2 and 3 is that level 2 is mostly adding purpose connectors for MCU functions, where level 3 generally needs support chips or areas for peripherals to reside.

There might only be 1 type of level 1 module, but as the levels get more complex, the number of variants would increase to accommodate different feature sets.

I'm not a big fan of breadboard areas on a dev card since it wastes space and I generally use custom PCBs to perform "breadboard" functions.

If modules try to make a one-size-fits-all solution it ends up to have a lot of wasted resources or it is too costly or it consumes too much power or it is too big.

I just want to point out one feature, which is really nicely done on both of those boards. The markings of connectors and everything else in silkscreen. Pin numbers or signal labels in readable size, also the grid on the prototyping area.

TLDR: If there is room, add more text.

At uni I used this microcontroller dev-board quite a few times:

 (Image source: Google Images)

the play area on the right was really handy for making projects. There wasn't really much else that the board did. It had built-in RS232 for programming or comms. It had an option for adding a real-time clock. I really liked it so after I left uni I made my own version of this (on proto-board with tons of wiring,no PCB) but with the microcontroller replaced with a version that could have external memory (I think I used parallel EEPROM). That helped loads, since otherwise you had to run code from RAM (which was limited to 512 bytes), or use one-time programmable ROM, or EPROM window versions.

I learned these suggestions that suited me, but might not suit everyone, when working on the Pico Eurocard:

1. Keep it simple
2. At least two connections per pin, using pin headers or whatever your favorite connectors, makes it easy to simultaneously probe. Try to make it easy to access buses like I2C, SPI.
3. Examine the chip datasheet, and see which pins are are least likely to be needed for SPI/I2C etc, and use them for some sort of minimal I/O like buttons and LEDs, but use jumpers to disable or re-patch them to other I/O if needed
4. If there is no USB serial debug capability on the microcontroller, then strongly consider adding at least the UART connections onto a pin header, laid out to fit your favorite USB-UART adapter, or better yet, solder one permanently on, since it helps troubleshooting immensely if you can use print statements in your code. I also like creating a keypress entry menu, so that code can be tested without requiring buttons/displays
5. Use the ARM SWD or JTAG connections (or whatever the microcontroller supports) because it can often be much quicker. This is easy with the Pico becase the debugger happens to be another RP2040 in that XIAO module of course.
6. You can't please everyone, everyone will have their preferred displays and connectors and so on, so consider the board as a kind of test card for the processor, and just have plenty of connections for easy extension. In other words, keep it simple.
7. If you're creating a prototyping area, then if you deliberately don't make the pads through-hole, then components are extremely easy to desolder, since the copper won't quite reach the drilled holes, it will automatically be set back a bit, with all low-cost prototyping services.
8. If you use an ecosystem a lot, like MikroBus, then you could either add the footprint, or alternatively make yourself a carrier card/plug on board for it.
9. Since it's a dev-board/test card, it doesn't need to be ultra-compact. Consider 100x100 mm as a starting point, since that is often a low cost from the PCB services.
10. Since the user will often need access to connections, it often rules out a plastic enclosure, but instead consider either mounting feet, or use screw-holes to attach a plastic plate on the underside and top. The latter is usually an excellent idea, since you don't want a stray wire on your desk to touch something.

A silkscreen that is easy to read.. (on both sides)

Ohh and Micropython support

I'm also finding the built-in supplies really handy. I like working on laptop on sofa or wherever, and it means I can just use any DC power supply, and have access to 5V or 3.3V rails for circuitry. I'm using the supply feature a lot (although the Pico is unusual in that it is fairly generous with what it can supply). 

The 68HC11 was an awesome chip at the time.

Keep it simple.

Power supply input, on board regulator and clock.

Break out every pin.

Serial port, debug programming port.

0.1" headers are good and cheap but sometimesd take up too much room.

Some mounting holes so the board can be fixed to box or other boards.

I've been using my little display board as a general purpose micro board recently (where others might use a Pico or an Arduino).

The display board is the one in the vice. It doesn't have much more than the absolute basics (it has power siwtches for the displays and a possible back light.) The serial interface doesn't use an RS232 drive chip but works at logic level.

The thing it's connected to is a multiplexer and DC bias injector for an LCR meter. (I'll blog about it when it's working a bit more.)

MK

Perhaps may need to differentiate between different classes of board definition here, although with access to cheap one-off PCB manufacture these days, and entire systems on a single chip, then the lines may have now blurred a bit.

The first board looks more like a trainer or prototyping class board as it has additional IO devices included on the board and looks like it may be used many times for different tutorial type projects. The breadboard suggests that it may be used for many different hardware designs throughout its life.

Shabaz' board looks more like a dev board that might be used primarily for developing a single project prior to a first PCB design. It looks like it could be populated with additional components and be slotted into a rack enclosure for prolonged testing. It has options for additional debugging type modules but doesn't have much in the way of on-board IO devices. 

Historically that first one-off PCB would have been an expensive step, and it was likely cheaper to get a mass-produced 'dev board' that basically provided you with the device plus supporting hardware with its pins broken out to easy to work with connections.

Then there is the likes of the evaluation board which may have minimal core components plus a specific sensor or actuator intended to allow you more quickly test the functionality of a specific device.

I like simplicity.  As they say less is more.  Important criteria for me is:

1. Easy method to configure

2. Easy method to power

3. Sufficient I/O made accessible (as others have mentioned)

4. If the board can act as a module and be mounted on a custom board to add extra functionality that is great too.